Prácticas de introducción

Laboratorio de Administración y Gestión de Redes y Sistemas
Grado en Ingeniería Telemática, 2023-2024
Escuela de Ingeniería de Fuenlabrada
Universidad Rey Juan Carlos

Cambios en el documento

Formato de la memoria de prácticas

La memoria de estas prácticas debes escribirla en un fichero en formato markdown. El fichero estará en tu cuenta del laboratorio. El dia del examen, recogeremos automáticamente tus prácticas.

  1. Es imprescindible que respetes al pie de la letra los nombres de los ficheros especificados en el guión. Una letra mal puesta equivale a una práctica no presentada (o un examen no presentado). Si bien dispondrás de un script que verificará que has usado los nombres correctos

  2. Redacta la memoria describiendo escuetamente todo lo que haces. Esta memoria te será muy útil para preparar el examen práctico (recuerda que podrás llevarla al examen).

    No merece la pena que te preocupes de tener una redacción muy cuidada: copia y pega órdenes y resultados, describe telegráficamente lo que haces. Vete preparando la memoria a la vez que trabajas, no lo dejes para el final.

    1. Cuando un paso del guión te pida una orden de shell o similar, es recomendable que primero ejecutes la orden y luego copies y pegues en la memoria. Si resulta algún texto, pégalo también.

    2. Cuando el guión pida que escribas o edites un fichero, basta con que lo modifiques en su sitio. No es necesario que copies y pegues en la memoria.

Práctica 1.1. Directorios de las prácticas

Ahora prepararás el directorio de la práctica 1 y el fichero de texto para la memoria de la esta práctica.

  1. Entra en tu cuenta del laboratorio Linux de la ETSIT. Crea el directorio ~/lagrs. Aquí guardarás la mayoría de tu trabajo de prácticas en la asignatura

  2. Ponle permisos rwx------

    Debes mantenerlo así todo el curso. Recuerda que debes ser autor del 100% de tus prácticas y no permitir que ningún compañero tuyo tenga acceso a ningún fragmento.

  3. Crea el directorio

    ~/lagrs/practica01

  4. Crea el fichero

    ~/lagrs/practica01.md

    Observa que el nombre de este fichero no es

    ~/lagrs/practica01/practica01.md # ¡Este no es el nombre correcto!

    Por el momento déjalo vacío.

  5. Crea un directorio

    ~/lagrs/images

    para las imágenes de tus memorias de prácticas (aunque tal vez tus ficheros no tengan imágenes)

  6. Seguiremos este convenio en todas las prácticas, un directorio para cada práctica y un fichero de texto plano para cada práctica, fichero que cuelga de ~/lagrs

Práctica 1.2. Uso básico de vi

El objetivo de esta práctica es que sepas usar al menos las órdenes elementales de vi. Si no te gusta este editor, podrás usar algún otro editor sencillo en modo texto. Pero para poder instalar un editor nuevo, necesitas usar vi.

  1. Usando vi, crea el fichero ~/lagrs/practica01/ejemplo.md y escribe en él 4 titulares de cualquier periódico de hoy. Escribe 3 o 4 faltas de ortografía, intencionadamente. Guárdalo.

  2. Vuelva a abrirlo y corrige las faltas.

Práctica 1.3. Uso de un editor sin gráficos

Ahora empezarás a usar el fichero de la memoria de prácticas. Escribe la memoria de este apartado y de todos los apartados siguientes de esta práctica en el fichero que creaste en el apartado 1.1. ~/lagrs/practica01.md

Es necesario que manejes con soltura funciones al menos intermedias de algún editor de texto sin gráficos. La recomendación es vi/vim, pero también puedes elegir uno más sencillo.

  1. Lee las transparencias sobre editores de texto. Arranca al menos una vez los editores en modo texto presentados (vim, mcedit, joe y nano). Elige uno, para usar en esta asignatura. ¿Cuál has elegido? ¿por qué?. Puedes cambiar de opinión mas adelante, pero en tal caso, indícalo (recuerda que estas prácticas las recogeremos el día del examen).

  2. Es muy conveniente conocer atajos de teclado. Es mucho más eficaz memorizar, por ejemplo, 2 al día durante 5 días que intentar retener 10 atajos 1 día. Aprende unos cuantos de esta forma, al menos media docena, e indícalo aquí. Ejemplo:

    2022.09.24
Elijo vi porque es el más potente. Practico el copy-paste con yy p
2022.09.28
Me coloco en una palabra y pulso asterisco para buscar esa misma palabra
en el texto. n minúscula para repetir la búsqueda hacia adelante y N mayúscula
para buscar hacia atrás.
2022.09.30
Practico ma, mb, mc para poner las marcas a, b y c en un texto. Vuelvo
a las marcas con 'a 'b 'c

Práctica 1.4. Markdown

Prepara un documento llamado

~/lagrs/practica01/test_markdown.md

  1. Escribe en él un texto de prueba con diferentes secciones, negritas, cursivas, enlaces, imágenes, listas de varios tipos, código fuente y alguna tabla.

  2. Usa pandoc para limpiar el fichero.

  3. Usa pandoc para generar una versión en html usando alguna de las plantillas css que vimos en clase.

Práctica 1.5. Gestión de contraseñas

Guarda dos o tres contraseñas, de prueba o reales, usando

  1. gpg

  2. LibreOffice

  3. KeePassx. O alguna herramienta similar como Bitwarden.

Usa recordatorios de contraseña en todos los casos, en un fichero de texto aparte. Guarda los ficheros donde quieras, describe brevemente en la memoria los pasos que has seguido

Práctica 1.6. Secret Sharing

Usa ssss para descomponer una contraseña en 6 trozos, de forma que baste con 4 para restaurarlos. Recomponla.

Práctica 1.7. Vagrant

En este ejercicio probarás Vagrant, lanzando una máquina virtual de VirtualBox. Si quieres hacer esta práctica en tu ordenador de casa, tendrás que instalar Vagrant y VirtualBox si no lo tenías ya.

  1. Si estás en el laboratorio, configura VirtualBox para usar /var/tmp/tulogin como carpeta predeterminada de máquinas

  2. Crea un project directory de Vagrant en el directorio ~/lagrs/vbox01 de tu pc (de casa o del laboratorio)

  3. Prepara una máquina Ubuntu 22.04 LTS Jammy Jellyfish

  4. Lanza la máquina y entra por ssh, usando vagrant.

  5. Comprueba que el project directory del host está montado dentro de la máquina virtual en /vagrant

    Para ello, edita un fichero en este directorio desde el guest o el host, guárdalo y vuelve a editarlo desde la otra máquina (el host si antes usaste el guest y viceversa).

  6. Apaga la máquina desde vagrant, sin destruirla.

  7. Si hiciste la práctica en casa o en tu portátil, copia el directorio ~/lagrs/vbox01 de tu pc de al directorio ~/lagrs de tu cuenta del laboratorio. De esta forma, el directorio ~/lagrs/vbox01 de ambas máquinas será idéntico.

Práctica 1.8. Usuarios y grupos

En este ejercicio practicarás con los usuarios y grupos de linux.

  1. Vuelve a entrar en la máquina virtual del apartado anterior.

  2. Crea un nuevo usuario, con el mismo nombre que tu usuario en el laboratorio.

  3. Abre una sesión de este usuario (con la orden su).

  4. Este usuario no tendrá privilegios para ejecutar sudo, pero intenta lanzar alguna orden y observa qué pasa.

  5. Haz que este usuario sí pueda ejecutar sudo. Pruébalo.

  6. Con este usuario, crea dos nuevos grupos con el nombre que quieras. Mete al usuario en estos grupos. Comprueba que están incluidos.

  7. Prueba la orden newgrp, observa su efecto.

Práctica 1.9. ssh sin contraseñas (1)

Configura tu cuenta del laboratorio para entrar desde cualquier máquina hasta cualquier máquina, sin escribir contraseña.

Práctica 1.10. ssh sin contraseñas (2)

Configura la máquina virtual vbox01 para poder abrir una sesión del usuario que creaste en el apartado 1.8, desde tu cuenta del laboratorio, sin escribir contraseña.

Práctica 1.11. tar

Prueba el uso de tar y bz2 para comprimir y descomprimir ficheros, tal y como hemos visto en las primeras páginas de la presentación Administración de Servicios y Aplicaciones

Práctica 1.12. split

Ahora practicarás con el troceado de ficheros. Supongamos que quieres mover la máquina que acabas de crear a un host distinto. No es un fichero excesivamente grande pero sí tiene cierto tamaño, puede ser conveniente trocearlo. Es lo que practicarás aquí.

  1. Desde el interfaz gráfico de VirtualBox, exporta la máquina virtual vbox01. Usa el fomato ova. Llévalo al directorio auxiliar que prefieras.

  2. En ese directorio auxiliar, crea un fichero README.txt. En este fichero escribe el hash MD5 del fichero .ova.

  3. Comprime este directorio con el .ova y el .txt en un fichero .tgz. Ponle el nombre que te parezca adecuado.

  4. Divídelo en trozos, del tamaño que te parezca adecuado.

  5. Destruye la máquina virtual en VirtualBox (como prefieras, desde Vagrant o desde el GUI)

  6. Borra el .ova, conservando el fichero de texto con el hash.

  7. Borra el tgz. (En otras palabras, borra todo menos los trozos y el hash)

  8. Reconstruye el tgz a partir de los trozos.

  9. Extrae los ficheros, comprueba que el hash es correcto.

  10. Importa el .ova desde el GUI de VirtualBox, comprueba que funciona correctamente.

Práctica 1.13. rsync

Elige los directorios que quieras en las máquinas que quieras (una local, otra remota). Debes poder acceder desde la local a la remota sin escribir contraseña. Usando rsync:

  1. Clona un directorio local en uno remoto.

  2. Clona un directorio remoto en uno local.

  3. Consulta la página de manual, elige tres opciones y comprueba que se comportan como deben.

Práctica 1.14. FreeFileSync

Ahora practicarás el uso de FreeFileSync para simular que sincronizas tu pc de casa con el laboratorio. Empieza creando en tu pc las carpetas ~/simula_labo/lagrs y ~/simula_casa/lagrs. Vamos a imaginar que

  1. La carpeta ~/simula_casa/lagrs es la carpeta lagrs de tu ordenador de casa.

  2. La carpeta ~/simula_labo/lagrs es la carpeta lagrs de tu cuenta en el laboratorio.

Una vez que lo tengas todo preparado, ya puedes hacer esta práctica:

  1. Prepara un fichero ~/simula_labo/lagrs/prueba.txt. Escribe cualquier texto.

  2. Simula que vas a casa y allí añades una línea más. (por ejemplo ahora estoy en casa). Simula que vuelves al laboratorio y que vuelves de nuevo a casa. Recuerda que cada vez que estás en casa, tienes que sincronizar al principio y al final de la sesión.

Práctica 1.15. Conflictos con FreeFileSync

  1. Operando de forma análoga al ejercicio anterior, y con los mismos ficheros, simula un conflicto de sincronización. Observa los mensajes de error de FreeFileSync.

  2. Resuelve el conflicto. Comprueba que FreeFileSync ya no muestra errores.

Práctica 1.16. Sincronización real de tu cuenta (práctica imprescindible)

Prepara en tu PC de casa un directorio con nombre lagrs, en el directorio que prefieras (mis documentos, escritorio...) y sincroniza allí tu cuenta lagrs del laboratorio. Mantenlo sincronizado todo el curso. Te será util como copia de seguridad y para trabajar indistintamente en ambos entornos. Recuerda que eres responsable de custodiar tus prácticas: tu directorio del laboratorio podría perderse. (Sería raro pero no imposible, el servicio ofrecido es de tipo best effort).

En otras palabras: si haces mal esta práctica, si no mantienes durante todo el curso una copia de seguridad de tu trabajo, podrías suspender la asignatura.

Práctica 1.17 Servidor doméstico

Prepara un ordenador en tu casa de forma que puedas abrir una sesión de ssh (y por tanto de scp y de sftp) desde cualquier lugar de internet. Para ello

  1. Abre el puerto 22 de tu router para redirigirlo al puerto 22 del ordenador de casa donde quieras entrar.

  2. Abre una cuenta gratuita en noip.com. Instala en tu ordenador de casa el cliente de noip.com.

    Recibirás cada mes un e-mail pidiendo que confirmes que sigues interesado en mantener el dominio. Confírmalo, al menos hasta que apruebes la asignatura.

Práctica 1.18 Invocación de la shell

  1. Observa los ficheros de inicio de la shell de tu cuenta del laboratorio. Créalos si no los tienes. ¿Cuándo se ejecuta .bashrc? ¿Solamente en las shell de login? ¿Solamente en las shell que no son de login? ¿O en ambos tipos de shell? ¿Por qué?

  2. Comprueba que los diferentes tipos de ficheros que se tienen que ejecutar en la invocación de la shell (interactivo y de login, interactivo no de login, no interactivo) se comportan como cabe esperar. Usa trazas como

    echo prueba blabla

    o

    echo prueba blabla >> /tmp/mi_traza.txt

  3. Prepara tu cuenta del laboratorio para que el .bash_profile invoque al .bashrc (si es que no está así ya). Es recomendable que también lo hagas en tu pc de casa.

  4. Usando la máquina virtual, comprueba qué sucede cuando, desde la shell, cambiamos de usuario mediante la orden su. ¿Qué ficheros se ejecutan? ¿Pasamos a tener una shell de login o no?

  5. Define en .bashrc un alias que pueda usarse para un ataque o una broma. Haz una demostración.

Práctica 1.19. Instalación de Docker

En este apartado instalarás Docker en una máquina Linux

  1. Instala el paquete docker.io en la máquina virtual vbox01

  2. Comprueba que la instalación de docker es correcta, lanzando un contenedor de tipo holamundo basada en debian.

  3. Haz una prueba de tipo holamundo basada en ubuntu.

Práctica 1.20. Uso básico de imágenes

En este apartado empezarás a usar los contenedores en la máquina virtual vbox01. Mientras el enunciado no especifique lo contrario, usa imágenes basadas en Ubuntu 22.04.

  1. Crea un contenedor interactivo. No le pongas nombre. Ejecuta alguna orden básica de la shell. Indica alguna orden básica que esté disponible y alguna otra que no.

  2. No detengas el contenedor. Crea otro contenedor interactivo, poniéndole el nombre xxxxc01, donde xxxx son las primeras 4 letras de tu nombre de usuario en el laboratorio. Para jperez, sería jperc01.

  3. En un nuevo terminal, usa las ordenes de docker listar contenedores e imágenes. Explica lo que estás viendo.

  4. Termina la ejecución de los contedores y observa el estado de las imágenes y de los contenedores detenidos.

  5. Comprueba que el sistema de ficheros dentro del contenedor no es persistente. Esto es: escribe algún fichero, apaga el contenedor, vuelva a entrar y observa que ha desaparecido.

Práctica 1.21. Creación de una imagen de un contenedor

  1. Crea una cuenta en docker hub.

  2. Prepara la imagen test/banner descrita en las transparencias, pero llámala tulogin/banner siendo tulogin tu nombre de usuario en docker hub.

  3. Lanza un contenedor con esa imagen.

  4. Modifica la imagen para que una vez lanzada, no solo muestre el banner sino que abra una shell

  5. Lanza un contenedor con la imagen para comprobar que puedes ejecutar la shell.

  6. Sube la imagen a docker hub.

Práctica 1.22. Creación de una imagen personalizada

En este apartado prepararás una imagen sencilla de un contenedor, dentro de la máquina virtual vbox01. Se llamará <TULOGIN>/cal, y lo único que hará será invocar a la orden de shell cal para mostrar el calendario del mes actual y concluir.

Vamos a establecer los siguientes convenios, que mantendremos el resto de las prácticas:

La siguiente tabla contiene todos los ficheros que usarás, con el nombre visto desde los hierros (el puesto del laboratorio) y el nombre visto desde dentro de la máquina vbox01

~/lagrs/vbox01/cal                       /vagrant/cal
~/lagrs/vbox01/cal/construye.sh          /vagrant/cal/construye.sh
~/lagrs/vbox01/cal/lanza_jpercal01.sh    /vagrant/cal/lanza_jpercal01.sh
~/lagrs/vbox01/cal/lanza_jpercal02.sh    /vagrant/cal/lanza_jpercal02.sh
~/lagrs/vbox01/cal/context               /vagrant/cal/context
~/lagrs/vbox01/cal/context/Dockerfile    /vagrant/cal/context/Dockerfile
~/lagrs/vbox01/cal/context/entrypoint.sh /vagrant/cal/context/entrypoint.sh

Atendiendo a estos convenios,

  1. Prepara la imagen del contenedor solicitado. La utilidad cal está en el paquete bsdmainutils.

  2. Prepara el script lanza_jpercal01.sh y lánzalo.

  3. Prepara el script lanza_jpercal02.sh y lánzalo.

  4. Ejecuta docker ps -a y docker images, y observa que, naturalmente, se puede comprobar que ambos contenedores están basados en la misma imagen.

Práctica 1.23. Provisionamiento de la máquina vagrant

Como sabes, la máquina vbox01 que lanzamos con Vagrant la consideramos de usar y tirar. No guardaremos dentro ningún fichero valioso, en cualquier momento podrás perderla si te sientas en puesto diferente del laboratorio, si entras en remoto al laboratorio a un puesto diferente o si el administrador del laboratorio borra el directorio /var/tmp/tulogin por falta de espacio. Esta pérdida no supondrá mayor inconveniente porque con Vagrant podrás preparar otra igual con mucha facilidad.

La máquina vbox01 es casi una máquina ubuntu tal cual, a la que en las prácticas 1.7 y 1.8 le hiciste algunos retoques a mano. En esta práctica, la configuración la haremos de forma automática, editando el fichero Vagrantfile. Prepara el fichero ~/lagrs/vbox01/Vagrantfile para que:

  1. El nombre de la máquina virtual visto desde el provider sea vbox01.

  2. El nombre de host, esto es, el nombre de la máquina virtual visto desde dentro de la misma máquina virtual sea también vbox01.

  3. La máquina tenga instalado docker.

  4. La máquina tenga un usuario con el mismo nombre que tu login en el laboratorio.

  5. Este usuario pueda lanzar docker.

Para comprobar que este ejercicio funciona correctamente, elimina (vagrant destroy) tu máquina actual, vuelve a crearla y comprueba que la configuración es correcta y que tu usuario puede lanzar un contenedor de prueba.

Práctica 1.24. Montaje bind

Ahora prepararás una imagen de un contenedor que hará un montaje de tipo bind. Este contenedor se ejecutará dentro de la máquina virtual vbox01, como todos los demás que preparemos en esta asignatura, sin necesidad de que el enunciado lo diga explícitamente.

Siguiendo el criterio establecido en el apartado anterior, y suponiendo que tu usuario sea jperez

Funcionamiento del contenedor:

Prueba del contenedor:

  1. Lanza el contenedor y escribe en el directorio montado un fichero con nombre hola_jperez

  2. Comprueba que ese directorio es persistente. Esto es, sal del contenedor, vuelve a lanzarlo y observa que el fichero hola_jperez sigue en su sitio.

  3. Accede a este mismo fichero desde vbox01. Comprueba sus permisos. Edita el fichero con un texto cualquiera. Comprueba que puedes ver el contenido tanto en vbox01 como en el contenedor.

Práctica 1.25. Montaje bind del home de un usuario

Ahora prepararás una imagen de un contenedor donde habrá un usuario que montará en el contendor su home del host (la máquina vbox01)

Recuerda que en vbox01 tienes un usuario con el mismo nombre que tu usuario del laboratorio. Este será el usuario con el que trabajarás, no el usuario vagrant

Siguiendo el criterio establecido en el apartado anterior, y suponiendo que tu usuario sea jperez

Funcionamiento del contenedor:

Prueba del contenedor:

  1. Lanza el contenedor y escribe en el directorio montado un fichero vacío con nombre hola_jperez

  2. Comprueba que ese directorio es persistente. Esto es, sal del contenedor, vuelve a lanzarlo y observa que el fichero hola_jperez sigue en su sitio.

Práctica 1.26. Conectividad entre contenedores

En este apartado instalarás sshd en un contenedor y probarás la red bridge de Docker.

Una vez que estén listas las imágenes, lanza ambos contenedores y, de forma interactiva, para cada uno de ellos

  1. Averigua su dirección IP.

  2. Haz ping a tu propio contenedor.

  3. Usando netstat, comprueba que el servidor sshd está funcionando. Pero no instales netstat en la imagen, instálalo solo en este contenedor en particular para esta prueba concreta (esto es, de forma interactiva).

  4. Entra por ssh en tu contenedor.

  5. Comprueba que puedes hacer ping al otro contenedor.

  6. Abre una sesión en el otro contendor.

Práctica 1.27. sshfs

Haz una prueba básica de sshfs. Si tienes aquí tu portátil, monta tu home del laboratorio en el directorio que prefieras de tu ordenador. Si no, monta tu home del laboratorio en el directorio /tmp/labo de la máquina vbox01.

Práctica 1.28. Contenedor con sshfs

En este ejercicio prepararás un contenedor docker, configurado en español, con un usuario del mismo nombre que tu cuenta del laboratorio, capaz de montar un directorio remoto, usando sshfs.

Para ello:

  1. Prepara la imagen con los paquetes necesarios, la configuración en español y un usuario.

  2. Lanza el contenedor con las opciones necesarias para usar sshfs.

  3. Empieza probando sshfs desde el usuario root del contenedor:

    Monta el directorios /tmp de una máquina cualquiera de las que estén disponibles en el laboratorio (consulta el parte de guerra). Por ejemplo f-l2108-pc05 en el directorios /tmp/pc05 del contenedor. (Esto es, el directorio local será /tmp/pcNN, siendo NN el número del puesto)

    Comprueba que el resultado es el esperado: entra por ssh en esa máquina, edita algún fichero en el directorio /tmp/, comprueba que puedes editar el mismo fichero en el directorio montado en tu máquina local.

  4. Ahora repite el paso anterior pero con tu usuario del contenedor, no con el usuario root.

Práctica 1.29. Contenedor con fichero hosts

En este apartado prepararás un contenedor preparado para hacer ping y ssh a las máquinas del laboratorio, usando solo el nombre de host, no el FQDN (Fully Qualified Domain Name).

Esta imagen se llamará <TULOGIN>/chosts (contenedor hosts), estará basada en Ubuntu 22.04 y configurado en español.

Siguiendo el convenio descrito en el apartado anterior:

Para conseguir que los contenedores conozcan las direcciones IP de las máquinas del laboratorio, tendrás que añadir al fichero /etc/hosts de cada imagen las entradas correspondientes al laboratorio, que encontrarás en el fichero /etc/hosts de cualquier puesto.

Para ello

Comprueba que una vez lanzado el contenedor, puedes hacer ping o entrar por ssh a los puestos del laboratorio que lo soporten, sin necesidad de escribir el FQDN, esto es, sin añadir al nombre el dominio aulas.gsyc.urjc.es.

Ten en cuenta que: