Prácticas de introducción

Laboratorio de Administración y Gestión de Redes y Sistemas
Grado en Ingeniería Telemática, 2019-2020
Escuela Técnica Superior de Ingeniería de Telecomunicación
Universidad Rey Juan Carlos


Formato de la memoria de prácticas

La memoria de estas prácticas debes escribirla en un fichero en formato de texto plano. 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

  1. 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.txt

    Observa que el nombre de este fichero no es

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

    Por el momento déjalo vacío.

  5. 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.txt 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

Escribe la memoria de este apartado y de todos los apartados siguientes de esta práctica en ~/lagrs/practica01.txt

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 puedes elegir otro.

  1. Lee las transparencias sobre http://gsyc.urjc.es/ mortuno/lagrs/editores.pdf. 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:

    2015.09.24
    Elijo vi porque es el más potente. Practico el copy-paste con yy p
    2015.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.
    2015.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. Gestión de contraseñas

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

  1. gpg

  2. LibreOffice

  3. KeePassx

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.5. Secret Sharing

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

Práctica 1.6. Vagrant

En este ejercicio probarás Vagrant, lanzando una máquina virtual de VirtualBox

  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 ~/lagrs/vbox01

  3. Prepara una máquina Ubuntu 18.04 LTS Bionic.

  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.

Práctica 1.7. 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 nombre que quieras.

  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.8. Instalación de Docker

En este apartado instalarás Docker dentro de una máquina virtual.

  1. Comprueba que VirtualBox sigue configurado para que las imágenes de las máquinas virtuales estén en /var/tmp/tulogin y no en tu directorio home

  2. Instala docker en la máquina virtual vbox01 que preparaste en la práctica 1.6

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

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

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

En este apartado empezarás a usar los contenedores. Mientras el enunciado no especifique lo contrario, usa imágenes basadas en Ubuntu. La práctica es sencilla, pero es importante que prestes atención sobre si estas ejecutando órdenes en tu puesto del laboratorio, en la máquina VirtualBox lanzanda mediante Vagrant o en el contenedor. Para ello, simplemente fíjate en el prompt.

  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 dentro de la máquina virtual 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 de la máquina virtual, 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.

Práctica 1.10. 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.11. Creación de una imagen personalizada

En este apartado prepararás una imagen sencilla de un contenedor. 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:

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.12. FreeFileSync

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

  1. El puesto físico del laboratorio es tu ordenador de casa.

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

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

Observaciones:

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

  1. Prepara un fichero ~/simula_labo/lagrs/pueba.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, compilar en casa y compilar en la máquina virtual.

Práctica 1.13. 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.14. ssh sin contraseñas, desde máquina virtual

Configura la máquina virtual que preparaste con vagrant para entrar en tu cuenta del laboratorio sin escribir contraseña.

Práctica 1.15. ssh sin contraseñas, desde el laboratorio

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

Práctica 1.16. Reutilización de claves

  1. Guarda en tu cuenta del laboratorio el par de claves de la práctica 1.14.

  2. Inhabilita (provisionalmente) la clave pública de la práctica 1.15. Comprueba que esta clave ya no funciona.

  3. Usando la clave privada de la práctica 1.14, entra desde tu puesto físico en una máquina virtual del laboratorio.

  4. Vuelve a habilitar las claves de la práctica 1.15.

Práctica 1.17. Montaje bind

En este ejercio prepararás una imagen que cree un contenedor que haga un montaje de tipo bind. En este ejercicio, usarás un único contendor. Lo lanzarás en tu máquina virtual dentro de Virtual Box, configurada mediante Vagrant, como en los ejercicios anteriores.

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 es persistente. Esto es, sal del contenedor, vuelve a lanzarlo y observa que el fichero hola_jperez sigue en su sitio.

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. Define en .bashrc un alias que pueda usarse para un ataque o una broma. Haz una demostración.

Práctica 1.19. Dockerserver

Configura tu puesto del laboratorio para usar el servidor de contenedores docker del laboratorio. Su nombre es dockersever. El profesor te facilitará su dirección IP y las credenciales. También se las puedes pedir a un compañero, pero por favor no las distribuyas fuera del ámbito de la asignatura.

Práctica 1.20. Selección del servidor Docker

Ahora practicarás cómo configurar tu sistema para usar el servidor de contenedores local o el remoto. Recuerda: si las variables de entorno apuntan a un servidor remoto, se usa el remoto. Si no hay variables de entorno relativas a docker, se usa el local.

  1. Configura vbox01 para usar el dockerserver.

  2. Abre un nuevo terminal en esta máquina y lanza allí el servidor docker de la misma vbox01, no el dockerserver. Usa la orden unset para esto.

Práctica 1.21. 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). Lanza los contenedores en dockersever, no en vbox01.

Esta imagen se llamará <TULOGIN>/caa (contenedor aa).

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:

Práctica 1.22. sshfs

Ahora practicarás con sshfs. Escribe un script llamado ~/lagrs/practica01/monta_tmp que monte los directorios /tmp de f-l-vm01, f-l-vm02, f-l-vm03 en ~/lagrs/practica01/tmp01, ~/lagrs/practica01/tmp02, ~/lagrs/practica01/tmp03 respectivamente.

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

Práctica 1.23. Conectividad entre contenedores

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

  1. El nombre de la imagen que crearás será <TULOGIN>/cab

    Como en la práctica 1.21, al nombre de cada contenedor le añadirás como prefijo las primeras 4 letras de tu usuario, y como sufijo, un número de dos dígitos.

  2. Al igual que en la práctica 1.21, desde este contenedor debe ser posible acceder por ssh a los puestos del laboratorio sin usar su FQDN. También lanzar peticiones ping e usar ifconfig.

  3. Lanzarás dos contenedores con esta imagen.

    Por tanto, los nombres de los ficheros necesarios serán:

    ~/lagrs/cab/context/Dockerfile

    ~/lagrs/cab/context/entrypoint.sh

    ~/lagrs/cab/construye.sh

    ~/lagrs/cab/lanza_jpercab01.sh

    ~/lagrs/cab/lanza_jpercab02.sh

  4. Prepara la imagen de forma que el contenedor que la ejecute tenga lanzado el demonio servidor de ssh.

  5. Averigua la dirección IP de cada contenedor

  6. Haz ping entre ambos

  7. Añade un usuario a jpercab01

    Hazlo de forma interactiva, esto es, desde la shell. Elige el nombre y contraseña que quieras.

  8. Abre una sesión desde jpercab02 hasta jpercab01