Terminal, ficheros y permisos

Introducción

Antes de automatizar procesos de datos hay que poder localizar archivos, entender dónde se ejecuta una orden y evitar cambios fuera del espacio de trabajo. Esta primera parte ocupa dos sesiones. No presupone que todos los conocimientos de Linux estén frescos: avanza desde la preparación del laboratorio hasta la ejecución segura de un script.

Objetivos

• Preparar un laboratorio reproducible con Docker y Debian Trixie.
• Distinguir terminal, shell, comando, opción y argumento.
• Navegar mediante rutas absolutas y relativas dentro de un espacio de trabajo controlado.
• Crear, copiar, mover y consultar archivos.
• Interpretar permisos básicos y conceder ejecución a un script sin abrir permisos innecesarios.
• Crear usuarios y grupos de laboratorio y comprobar cómo afectan al acceso a archivos.

1. Preparar el laboratorio: Docker y Debian

Los ejercicios de M00 se realizarán en un contenedor con Debian Trixie. Docker permite ejecutar ese entorno aislado sin instalar Debian como sistema operativo principal.

• Una imagen es la plantilla descargable, en este caso debian:trixie.
• Un contenedor es una instancia de esa imagen en ejecución.
• Un montaje de carpeta o bind mount comparte una carpeta concreta del equipo anfitrión con el contenedor. Usaremos una carpeta local bda-m00, visible dentro de Debian como /bda-m00.

Antes de continuar, instala y abre Docker Desktop. La guía de instalación y puesta en marcha está disponible en UD00 — Modelos de IA.

También crea en tu equipo una carpeta para organizar los apuntes y recursos de la asignatura, donde te resulte cómodo: por ejemplo, BigDataAplicado en el Escritorio. Dentro de ella crea una carpeta llamada bda-m00. Esta segunda carpeta será el espacio de ejercicios compartido con Debian:

BigDataAplicado/
└── bda-m00/        ← carpeta local que compartiremos

Nota

No crearemos un volumen nombrado con docker volume create. Ese tipo de volumen lo administra Docker y no enlaza automáticamente una carpeta elegida del Escritorio. Aquí utilizamos un bind mount: los archivos de tu carpeta local bda-m00 y los de /bda-m00 en Debian son los mismos, no dos copias que debas sincronizar.

1.1. Compartir la carpeta local y crear el contenedor

Estas instrucciones son para crear el laboratorio por primera vez. Si Docker indica que el nombre bda-m00-debian ya está ocupado, no borres el contenedor ni repitas órdenes al azar: comprueba su configuración como se explica en el apartado 1.2. Un contenedor llamado igual no necesariamente está preparado como este laboratorio.

En la terminal de tu equipo anfitrión, sitúate dentro de la carpeta local bda-m00 que acabas de crear. Puedes abrir una terminal desde esa carpeta con el explorador de archivos de tu sistema. Comprueba la ubicación antes de crear el contenedor:

En macOS o Linux, con Bash/Zsh:

pwd
docker run -it --name bda-m00-debian -p 127.0.0.1:2222:22 -v "$(pwd):/bda-m00" debian:trixie bash

En Windows, con PowerShell:

Get-Location
docker run -it --name bda-m00-debian -p 127.0.0.1:2222:22 -v "$($PWD.Path):/bda-m00" debian:trixie bash

Ejecuta solo la variante correspondiente a tu sistema. La ruta mostrada debe terminar en tu carpeta bda-m00; no ejecutes la creación desde todo el Escritorio, desde tu carpeta personal ni desde el repositorio del docente. -v comparte una carpeta con la forma ruta-del-anfitrión:ruta-del-contenedor. $(pwd) en macOS/Linux y $($PWD.Path) en PowerShell representan la carpeta actual; /bda-m00 es su ubicación dentro de Debian. Las comillas permiten rutas con espacios. Esta sintaxis de preparación no hace falta memorizarla todavía.

La orden descarga la imagen si falta, crea el contenedor y abre Bash. Si Docker solicita permiso para compartir la carpeta, autoriza únicamente esa ubicación. No necesitas que la ruta del anfitrión se llame /bda-m00: ese es el nombre dentro del contenedor.

La opción -p 127.0.0.1:2222:22 publica el puerto 22 del contenedor en el 2222 del anfitrión, solo en su interfaz local. Reservamos esa comunicación para el servidor SSH del apartado 10; publicar el puerto no instala ni arranca el servidor. No utilizamos el puerto 22 del anfitrión para evitar conflictos con un servidor que ya exista allí.

La primera vez verás un prompt parecido a este:

root@identificador:/#

Estás dentro del contenedor y eres el usuario root de ese laboratorio aislado. Prepara las herramientas que se usarán durante M00. No hace falta memorizar estas órdenes de instalación:

apt update
apt install -y nano man-db less cron shellcheck adduser passwd util-linux openssh-client git

nano, los manuales y less se usan desde esta página; cron y ShellCheck se utilizarán más adelante. Instalarlos ahora evita que los bloques posteriores dependan de herramientas ausentes.

ShellCheck es una herramienta de análisis estático de código abierto diseñada para revisar scripts de shell sin necesidad de ejecutarlos.

adduser y passwd proporcionan las herramientas de usuarios y grupos; util-linux incluye su y flock. Si ya preparaste el contenedor antes de esta ampliación y tiene el montaje correcto, repite la instalación dentro de Debian como root; no vuelvas a crear el contenedor ni el volumen. Instalar paquetes no corrige un montaje que faltaba al crear el contenedor.

openssh-client permite estudiar el cliente SSH y la copia SCP; no instala un servidor SSH. Git se utilizará al final del módulo para conservar versiones locales de los scripts. No hace falta una cuenta de GitHub ni abrir puertos para estas actividades.

Para salir del contenedor escribe exit. En sesiones posteriores, vuelve a entrar desde la terminal del equipo anfitrión con:

docker start -ai bda-m00-debian

¿En qué se diferencia de docker exec? Ambas órdenes se escriben en la terminal del equipo anfitrión, pero sirven para situaciones distintas.

docker start -ai bda-m00-debian inicia el contenedor cuando está detenido y conecta tu terminal con su proceso principal. En nuestro laboratorio ese proceso es Bash, porque lo elegimos al crear el contenedor con docker run ... bash. La opción -a conecta la salida y -i la entrada, para poder escribir órdenes. Recuperas el mismo contenedor, sus archivos y su configuración; no creas otro.

Si el contenedor ya está en ejecución y quieres abrir otra terminal dentro de él, utiliza:

docker exec -it bda-m00-debian /bin/bash

exec ejecuta un proceso nuevo dentro del contenedor: aquí, una segunda sesión de Bash. -i mantiene abierta la entrada y -t proporciona una terminal interactiva. /bin/bash es el programa que quieres abrir. En la forma genérica docker exec -it [nombre_o_id_del_contenedor] /bin/bash, debes sustituir el marcador completo por el nombre o identificador real, sin escribir los corchetes. Para este laboratorio usa bda-m00-debian.

Esta diferencia será útil cuando necesites dos terminales para comprobar un bloqueo. Ambas sesiones acceden a los mismos archivos del volumen; sus variables y su directorio actual son independientes.

Referencia: documentación oficial de docker start y docker exec.

No elimines el contenedor ni la carpeta compartida durante M00. Al detener el contenedor se conservan los archivos en tu carpeta local bda-m00. Otro contenedor podría montar esa misma carpeta, pero los paquetes, usuarios y tabla cron pertenecen al contenedor anterior: compartir archivos no recupera esa configuración. Tampoco muevas o renombres la carpeta local mientras la utilices como origen del montaje.

Precaución

Los cambios son reales en ambos sentidos: si borras un archivo de /bda-m00 dentro de Debian, también desaparece de la carpeta local. Comparte solo la carpeta de prácticas, no directorios personales completos. Un montaje compartido no es una copia de seguridad.

Importante

Desde el apartado 2 en adelante, las órdenes se ejecutan dentro de Debian. Todos los ejercicios se hacen en /bda-m00, la carpeta compartida que acabas de montar. Cuando los apuntes mencionen el volumen o espacio de trabajo, se refieren a este montaje, no a un volumen nombrado independiente.

1.2. Comprobar el laboratorio antes de empezar

Que Docker esté abierto significa que puedes gestionar contenedores, no que el contenedor de M00 esté iniciado ni correctamente configurado. Desde la terminal del anfitrión, consulta:

docker ps -a --filter name=bda-m00-debian
docker inspect bda-m00-debian --format '{{range .Mounts}}{{println .Type .Source .Destination}}{{end}}'

docker ps -a incluye también los contenedores detenidos. La columna STATUS permite distinguir Up (en ejecución) de Exited (detenido). docker inspect consulta la configuración existente; el formato muestra tipo, ruta de origen y destino de los montajes. En un ejemplo de macOS podría aparecer:

bind /Users/ana/Desktop/BigDataAplicado/bda-m00 /bda-m00

La ruta intermedia será la de tu equipo, no la del ejemplo. Comprueba bind, tu carpeta de origen y /bda-m00 como destino. Si aparece volume en lugar de bind, utilizas un volumen administrado por Docker, no la carpeta local elegida. Si no aparece ningún montaje, no hay carpeta compartida. docker start y docker exec reutilizan la configuración: no añaden ni cambian el montaje. Crear /bda-m00 con mkdir dentro tampoco comparte archivos con el anfitrión.

Si el contenedor está en ejecución y tiene el montaje, entra con docker exec -it bda-m00-debian /bin/bash. Dentro de Debian, comprueba:

ls -ld /bda-m00
whoami
touch /bda-m00/comprobacion-compartida.txt

Busca comprobacion-compartida.txt en la carpeta local bda-m00 desde el explorador del anfitrión. Debe aparecer allí. Escribe dentro Prueba desde el anfitrión con un editor de texto y guarda como texto plano. De vuelta en Debian, ejecuta:

cat /bda-m00/comprobacion-compartida.txt

Debe mostrar esa frase: has comprobado escritura desde Debian y lectura de un cambio realizado en el anfitrión. touch crea el archivo si falta y no vacía uno existente; lo estudiaremos con detalle en el apartado 6. Si falla la escritura, revisa la ruta elegida y el permiso de compartirla en Docker Desktop; no uses sudo ni chmod 777 como arreglo automático.

La carpeta debe existir y el usuario inicial debe ser root. Si una orden como adduser o shellcheck muestra command not found, falta una herramienta: ejecuta de nuevo la instalación del apartado 1.1 dentro de Debian y comprueba que termina sin errores. La imagen mínima no incluye automáticamente todas las herramientas de unos apuntes de Linux.

Advertencia

Si falta el montaje o todavía utilizas un volumen nombrado, conserva el contenedor y sus datos antes de reemplazarlo. No uses docker rm ni borres volúmenes o carpetas para corregir el problema.

Cuando hayas identificado el montaje incorrecto, puedes conservar el contenedor con otro nombre. Si está ejecutándose, la primera orden lo detiene para liberar también el puerto 2222. Las órdenes siguientes se ejecutan en el anfitrión, una sola vez, y requieren que bda-m00-debian-anterior no esté ya ocupado:

docker stop bda-m00-debian
docker rename bda-m00-debian bda-m00-debian-anterior

Después, sitúate en tu carpeta local bda-m00 y ejecuta la variante de creación de 1.1 para tu sistema, ahora con el nombre original libre. Renombrar conserva el contenedor anterior y su volumen, si lo tenía, pero no copia sus archivos a la carpeta local. Si esta aparece vacía, no borres el origen: identifica primero qué datos deben recuperarse. Instala herramientas y prepara usuarios/servicios de nuevo en el contenedor nuevo. No se realiza una migración automática ni se sobrescriben datos previos.

Referencia: montajes de carpetas en Docker.

2. Leer el prompt y escribir una orden

La terminal es la aplicación donde escribimos órdenes. La shell es el programa que las interpreta; en este módulo usaremos Bash. En ejemplos de documentación se suele mostrar un símbolo $ antes del comando. Ese símbolo representa el prompt y no se escribe.

No son exactamente lo mismo: la terminal permite escribir y ver resultados, mientras que la shell interpreta la orden y solicita su ejecución. Puedes abrir distintas shells en una terminal. Bash, Zsh y Fish son ejemplos de shells; sus sintaxis no son idénticas. En estos apuntes utilizaremos Bash, tanto de forma interactiva como para escribir scripts.

La línea de comandos ofrece control sobre archivos y procesos y permite repetir operaciones sin recorrer menús. En un servidor, además, puede ser el único entorno disponible. Aprenderla nos servirá para localizar datos, diagnosticar errores y convertir después una secuencia de órdenes conocida en un script. No hace falta memorizar todas las opciones: hay que comprender la orden, consultar su ayuda y comprobar su resultado.

El prompt root@identificador:/# indica usuario (root), equipo o contenedor (identificador) y directorio actual (/). El signo # suele identificar una sesión administrativa; $, una sesión sin privilegios. Es una convención visual: el comando whoami, que veremos al estudiar permisos, comprueba la identidad real.

$ ls -la

En la terminal escribirías solamente:

ls -la

Una orden puede tener comando, opciones y argumentos:

ls        -la        /bda-m00
comando   opciones    argumento

ls solicita un listado, -la cambia el formato y /bda-m00 indica qué directorio listar. No todos los comandos necesitan las tres partes: pwd funciona sin opciones ni argumentos.

3. Observar sin modificar: ls y ayuda

Empieza con comandos que solo observan. En la carpeta compartida debe aparecer comprobacion-compartida.txt, creado al comprobar el montaje; también pueden aparecer otros archivos que ya conservaras allí.

ls /bda-m00
ls -l /bda-m00
ls -a /bda-m00
ls -la /bda-m00

Orden	Pregunta que responde
ls	¿Qué hay aquí?
ls -l	¿Qué hay y qué detalles tiene?
ls -a	¿Hay archivos ocultos?
ls -la	¿Qué hay, incluidos los ocultos, con detalle?

Si un tamaño en bytes cuesta de interpretar, añade -h al listado largo:

ls -lh /bda-m00

-h presenta tamaños con unidades legibles, como K o M. Puedes observar el archivo de comprobación y volver a probarlo después de crear las notas del apartado 6. El tamaño de una entrada de directorio en ls no representa la suma del contenido de ese directorio.

En una salida larga, el primer carácter indica el tipo: d es directorio y - es archivo normal. Los permisos se estudiarán en el apartado 7.

Cuando no conozcas una opción, consulta el manual en vez de probar al azar:

man ls
mkdir --help

Pulsa q para salir de man.

4. Crear un espacio de trabajo seguro

La raíz y los directorios del sistema

Linux organiza los archivos en un árbol que empieza en /, la raíz del sistema de archivos. No confundas / con /root: el segundo es el directorio personal del usuario root. Nuestro volumen está montado en /bda-m00, una rama de ese árbol.

Directorio	Para qué sirve	Relación con este laboratorio
/root	Directorio personal del administrador.	Es el directorio personal de la sesión inicial.
/home	Directorios personales de usuarios normales.	Más adelante se creará /home/alumno-m00.
/etc	Configuración del sistema y programas.	Consultaremos información de usuarios, sin editarla a mano.
/usr	Programas, bibliotecas y recursos instalados.	Contiene muchas herramientas que ejecutamos.
/var	Datos variables, incluidos registros del sistema.	No sustituye a nuestra carpeta de evidencias logs.
/tmp	Archivos temporales.	No debe usarse como lugar de entrega ni suponerse persistente.
/bda-m00	Volumen de trabajo del módulo.	Aquí guardaremos archivos, ejercicios y scripts.

Puedes observar el primer nivel del árbol sin modificarlo:

ls -l /
ls -l /home

El primer listado debe incluir bda-m00; /home puede estar vacío antes de crear usuarios. Que una carpeta exista no significa que debamos modificar su contenido. En Debian, /bin y /sbin pueden aparecer como enlaces hacia ubicaciones de /usr: no son dos instalaciones independientes de cada programa.

Antes de practicar rutas, necesitamos un árbol de directorios conocido. Trabajaremos solo dentro de /bda-m00, nunca directamente en /etc, /usr ni /var.

mkdir crea un directorio. Empieza sin opciones y con un único nombre:

mkdir /bda-m00/data

Ahora que existe data, puedes crear dentro otro directorio:

mkdir /bda-m00/data/raw
mkdir /bda-m00/logs
mkdir /bda-m00/scripts

Comprueba la estructura con un listado detallado:

ls -l /bda-m00
ls -l /bda-m00/data

Si necesitas crear de una vez una ruta cuyos directorios intermedios todavía no existen, mkdir -p los crea. Es útil, pero no sustituye a entender qué carpetas estás creando:

mkdir -p /bda-m00/entregas/semana-01

La estructura de trabajo queda así:

/bda-m00/
├── data/
│   └── raw/
├── entregas/
│   └── semana-01/
├── logs/
└── scripts/

data/raw guardará datos todavía no transformados; logs, evidencias de ejecución; scripts, programas Bash; y entregas, los archivos que prepares para una práctica.

5. Saber dónde estás: pwd y cd

El directorio de trabajo actual determina el significado de las rutas relativas. Entra en el volumen y muestra ese punto de partida:

cd /bda-m00
pwd

La salida debe ser /bda-m00. Ahora recorre la estructura una orden cada vez:

cd data
pwd
cd raw
pwd
cd ..
pwd
cd ..
pwd

.. es el directorio padre. Si te pierdes, vuelve siempre al punto de partida conocido:

cd /bda-m00
pwd

Rutas absolutas y relativas

Tipo	Ejemplo	Depende del directorio actual
Absoluta	/bda-m00/data/raw	No
Relativa	data/raw	Sí
Relativa al padre	../logs	Sí

. representa el directorio actual. Desde /bda-m00, data/raw, ./data/raw y /bda-m00/data/raw señalan al mismo sitio. Sin embargo, desde /bda-m00/logs la ruta relativa para llegar allí es ../data/raw:

cd /bda-m00/logs
pwd
cd ../data/raw
pwd
cd ../..
pwd

Debes obtener, en orden, /bda-m00/logs, /bda-m00/data/raw y /bda-m00. Cada .. sube un nivel; no significa «volver al lugar donde estaba antes».

Para volver al directorio anterior existe cd -:

cd /bda-m00/logs
cd /bda-m00/data/raw
cd -
pwd

cd - vuelve a logs y muestra la ruta. En cambio, ~ representa el directorio personal del usuario actual:

cd ~
pwd
cd /bda-m00

En nuestra sesión administrativa, el directorio personal es /root. cd sin argumentos también va al directorio personal. Al cambiar de usuario, ~ cambiará con él; no es un alias de /bda-m00.

Importante

Antes de crear, mover o borrar, ejecuta pwd. Un comando correcto en el directorio equivocado puede producir un resultado incorrecto.

6. Crear y consultar archivos

touch crea un archivo vacío. Crea un archivo de notas de prueba y comprueba su efecto:

touch /bda-m00/data/raw/notas-prueba.txt
ls -l /bda-m00/data/raw/notas-prueba.txt

El tamaño debe ser 0. Si el archivo ya existe, touch actualiza sus fechas sin vaciar su contenido. En la página 02 aprenderás a escribir mediante redirecciones; ahora puedes preparar un texto con el editor nano:

nano data/raw/notas-prueba.txt

Escribe tres líneas: Primera nota, Segunda nota y Tercera nota. Guarda con Ctrl + O, confirma con Intro y sal con Ctrl + X. Consulta después el mismo archivo de varias formas:

cat data/raw/notas-prueba.txt
head -n 2 data/raw/notas-prueba.txt
tail -n 1 data/raw/notas-prueba.txt
wc -l data/raw/notas-prueba.txt
less data/raw/notas-prueba.txt

cat muestra todo el texto; head -n 2, las dos primeras líneas; tail -n 1, la última; y wc -l cuenta saltos de línea (aquí debe indicar 3). less permite recorrer textos largos: pulsa q para salir. Verifica cada salida comparándola con las líneas que escribiste.

Editar y leer sin perderte

En nano, el cursor indica dónde vas a escribir. Las flechas lo desplazan; escribir añade texto y borrar elimina caracteres. La parte inferior muestra los atajos: ^ significa Ctrl. Por ejemplo, ^O corresponde a Ctrl + O.

Acción en Nano	Teclas	Comprobación
Guardar	Ctrl + O, confirmar con Intro	El editor confirma la escritura.
Salir	Ctrl + X	Vuelves al prompt; si hay cambios pendientes, pregunta si guardarlos.
Buscar	Ctrl + W, escribir texto, Intro	El cursor se coloca en una coincidencia.
Cortar la línea actual	Ctrl + K	La línea desaparece y queda en el búfer del editor.
Pegar lo cortado	Ctrl + U	El texto se inserta donde está el cursor.
Consultar ayuda	Ctrl + G	Aparece la ayuda y sus teclas de salida.

Abre las notas, busca Segunda, corta esa línea y pégala de nuevo en su posición original antes de guardar. Comprueba con cat que conservas las tres líneas en su orden. Cortar y pegar dentro de Nano no es lo mismo que usar el portapapeles del ordenador.

Para numerar las líneas al mostrarlas, sin cambiar el archivo:

cat -n data/raw/notas-prueba.txt

Debe mostrar los números 1, 2 y 3. cat -n numera todas las líneas; cat -b numera solo las no vacías. Ninguna de estas opciones guarda los números en el archivo.

En less, usa las flechas para desplazarte y la barra espaciadora para avanzar una pantalla. Escribe /Segunda y pulsa Intro para buscar; n busca la siguiente coincidencia y q sale. En nuestro archivo corto no hay varias pantallas, pero los mismos controles sirven para registros largos. head y tail, sin -n, muestran hasta diez líneas: sobre este archivo de tres líneas, mostrarán las tres.

cp copia; mv mueve o renombra; find busca. Desde /bda-m00, prueba con el archivo que acabas de crear:

cp data/raw/notas-prueba.txt data/raw/notas-copia.txt
mv data/raw/notas-copia.txt data/raw/notas-practica.txt
find data -type f -name '*.txt'

En find, data es el punto inicial de búsqueda, -type f selecciona archivos normales y -name '*.txt' filtra sus nombres. Las comillas hacen que sea find, y no la shell, quien interprete el patrón. La salida debe incluir el original y la copia renombrada.

Seleccionar nombres con comodines

La shell puede sustituir un patrón por los nombres que coinciden con él. * representa cero o más caracteres y ? exactamente uno. Esto se llama expansión de nombres y no es una expresión regular.

mkdir /bda-m00/seleccion
touch seleccion/nota1.txt seleccion/nota2.txt seleccion/notas.txt seleccion/datos.csv
ls seleccion/*.txt
ls seleccion/nota?.txt

La primera selección incluye los tres archivos de texto. La segunda también: ? coincide con 1, 2 o s, un único carácter después de nota. Para seleccionar solo los dos nombres numerados, concreta los caracteres admitidos:

ls seleccion/nota[12].txt

Los corchetes de este patrón aceptan un carácter de la lista. Deben aparecer nota1.txt y nota2.txt. La shell interpreta estos patrones antes de ejecutar ls; en find ... -name '*.txt' usamos comillas precisamente para que el patrón llegue a find sin esa expansión previa. No uses una selección con comodines para borrar hasta haber comprobado qué nombres selecciona.

Copiar no es mover

cp origen destino conserva el original y crea una copia. mv origen destino cambia la ubicación o el nombre: ya no queda un archivo en la ruta original. Prepara un ejemplo separado para no alterar las notas que reutilizaremos:

mkdir /bda-m00/gestion
cp data/raw/notas-prueba.txt gestion/notas.txt
cp gestion/notas.txt gestion/notas.bak
mv gestion/notas.bak gestion/respaldo.txt
ls -l gestion

Al final deben existir notas.txt y respaldo.txt, pero no notas.bak. Comprueba el contenido de ambos con cat: deben conservar las tres notas. Si el destino es un directorio existente, el archivo se coloca dentro con su nombre; si es un nombre de archivo, se copia o renombra con ese nombre.

Cuando el destino ya contiene un archivo con el mismo nombre, puedes sobrescribir datos. -i pide confirmación antes de sobrescribir:

cp -i gestion/notas.txt gestion/respaldo.txt

Responde n a la confirmación para conservar el destino. mv -i aplica la misma precaución al mover. No interpretes una orden sin salida como prueba de que nada ha cambiado: consulta los archivos después.

Copiar un directorio requiere recorrer su contenido. Para ello usamos cp -r:

cp -r gestion entregas/copia-gestion
ls -l entregas/copia-gestion

En la primera ejecución, copia-gestion no existe y se crea con los dos archivos. Si repites una copia de directorio hacia un destino que ya existe, la estructura resultante puede ser distinta: revisa primero el destino. No copies árboles del sistema para practicar.

Borrar con un objetivo concreto

rm elimina archivos; no los envía a una papelera. rmdir elimina directorios vacíos y se niega a eliminar uno con contenido. Trabaja únicamente con copias desechables:

cp gestion/notas.txt gestion/borrador.txt
ls -l gestion/borrador.txt
rm -i gestion/borrador.txt
ls -l gestion
mkdir gestion/vacia
rmdir gestion/vacia
ls -l gestion

En rm -i, confirma con y para eliminar la copia identificada; debe desaparecer borrador.txt, pero permanecer las notas y el respaldo. rm gestion/borrador.txt, sin -i, eliminaría esa misma copia sin preguntar si existiera. Después de rmdir, ya no debe aparecer vacia.

Para borrar un directorio con contenido existe rm -r, pero no lo necesitamos en estos ejemplos. Antes de cualquier borrado comprueba pwd, la ruta y su contenido. No uses rm -rf, rutas generales del sistema ni un comodín para «limpiar todo».

Limitar la búsqueda y consultar el espacio ocupado

find recorre los subdirectorios. Cuando solo necesitas explorar unos niveles, puedes limitar la profundidad:

find data -maxdepth 1 -type f -name '*.txt'
find data -maxdepth 2 -type f -name '*.txt'

El punto de partida data tiene profundidad 0; sus elementos directos, 1; y los archivos de data/raw, 2. Con la estructura que acabas de preparar, la primera orden no muestra archivos y la segunda muestra notas-prueba.txt y notas-practica.txt, con su ruta. El orden de aparición puede variar. La posición de -maxdepth antes de los filtros deja claro que limita el recorrido completo.

Para consultar el espacio ocupado por el directorio, usa du:

du -sh data
ls -lh data/raw/notas-prueba.txt

En du, -s pide un resumen y -h unidades legibles. La primera salida tendrá un tamaño y el nombre data; el valor exacto depende del sistema de archivos. ls muestra el tamaño del contenido del archivo y du estima el espacio que ocupa en disco, incluidos los elementos del directorio: no tienen por qué coincidir. Estas órdenes solo consultan, no borran ni modifican los datos.

En el módulo aparecerán archivos de cotizaciones como caso de aplicación, pero estos comandos sirven igual para apuntes, listados, registros o cualquier otro fichero de trabajo.

7. Permisos

Importante

En una carpeta compartida, el acceso también depende del sistema de archivos y los permisos del anfitrión. Con Docker Desktop en macOS/Windows, la representación de propietarios y modos puede diferir de un sistema de archivos Linux nativo. Los cambios que practiques afectan a los archivos locales: limita chmod y chown a las copias del ejercicio. Si un modo no se conserva o una lectura no se deniega como se espera, registra esa limitación y consúltala; no interpretes el resultado como una demostración válida ni abras permisos indiscriminadamente. Las pruebas anteriores sobre un volumen Docker no certifican este nuevo montaje.

Antes de interpretar el propietario de un archivo, comprueba con qué usuario estás trabajando:

whoami
id

En este laboratorio, whoami debe mostrar root. id muestra los identificadores del usuario y sus grupos; aparecerán uid=0(root) y gid=0(root). UID identifica al usuario y GID al grupo. No confundas ese usuario de Linux dentro del contenedor con tu cuenta del ordenador anfitrión: aquí no hemos creado un usuario de prácticas sin privilegios.

Linux distingue propietario, grupo y otros usuarios. Una línea de permisos se interpreta así:

- rwx r-x ---
│  │   │   └── otros usuarios
│  │   └────── grupo
│  └────────── propietario
└───────────── tipo de elemento (`-` archivo, `d` directorio)

En archivos, r permite leer, w modificar el contenido y x ejecutar. En directorios, r permite listar nombres, w modificar entradas (crear o eliminar elementos, normalmente junto con x) y x atravesar el directorio para acceder a sus elementos. Borrar un archivo depende de los permisos de su directorio, no solo del permiso de escritura del propio archivo. Observa los permisos de tu archivo:

ls -l data/raw/notas-prueba.txt

Un archivo recién creado suele mostrar permisos parecidos a -rw-r--r--: su propietario puede leer y escribir; el grupo y los otros usuarios solo pueden leer.

Precaución

No uses chmod -R, cambios de propietario ni permisos 777 para resolver un problema sin comprenderlo. Solo cambiaremos permisos y propietarios de archivos creados expresamente dentro del volumen, nunca del sistema ni de forma recursiva.

Cambiar permisos en forma simbólica

chmod modifica los permisos. En la forma simbólica, primero indicas a quién afecta: u propietario, g grupo, o otros y a todos. Después indicas la operación: + añade, - retira y = fija exactamente los permisos indicados para esa categoría.

cp data/raw/notas-prueba.txt gestion/permisos.txt
chmod u=rw,g=r,o= gestion/permisos.txt
ls -l gestion/permisos.txt
chmod g+w gestion/permisos.txt
ls -l gestion/permisos.txt
chmod g-w gestion/permisos.txt
ls -l gestion/permisos.txt

Debes ver sucesivamente -rw-r-----, -rw-rw---- y -rw-r-----. La primera orden fija las tres categorías; las siguientes añaden y retiran escritura al grupo sin cambiar las demás. No hace falta conceder ejecución a un archivo de notas para leerlo.

Cambiar permisos en forma octal

La forma octal representa cada categoría con una cifra. Suma 4 para lectura, 2 para escritura y 1 para ejecución:

Cifra	Permisos	Cálculo
0	---	Ninguno
4	r--	Lectura
5	r-x	4 + 1
6	rw-	4 + 2
7	rwx	4 + 2 + 1

Las tres cifras corresponden, por orden, a propietario, grupo y otros. 640 equivale a u=rw,g=r,o=. Compruébalo sobre la copia:

chmod 640 gestion/permisos.txt
ls -l gestion/permisos.txt
chmod 644 gestion/permisos.txt
ls -l gestion/permisos.txt

Ahora verás primero -rw-r----- y después -rw-r--r--: en el segundo caso, otros usuarios también pueden leer. Para un directorio propio podemos usar 750:

mkdir gestion/privada
chmod 750 gestion/privada
ls -ld gestion/privada

ls -d muestra la entrada del propio directorio, no su contenido; junto con -l, permite observar drwxr-x---. El propietario puede listar, crear y atravesar; el grupo puede listar y atravesar; otros no tienen acceso. 755 significaría rwxr-xr-x, no rwxr-xr--, que corresponde a 754.

8. Ejecutar un script de forma segura

Para crear el primer script sin usar todavía redirecciones, abre el editor de consola nano:

nano scripts/saludar.sh

Escribe estas dos líneas en el editor:

saludar.sh

#!/usr/bin/env bash
echo "El entorno de M00 está listo"

Guarda con Ctrl + O, confirma el nombre con Intro y sal con Ctrl + X. Al ser un archivo nuevo, no tiene permiso de ejecución. Concédelo solo al propietario:

chmod u+x scripts/saludar.sh
ls -l scripts/saludar.sh
./scripts/saludar.sh

El shebang indica qué intérprete usar. El prefijo ./ significa «ejecuta este archivo que está en esta ruta»; sin él Bash no busca automáticamente el directorio actual.

echo muestra un mensaje por la salida normal. chmod u+x añade x únicamente al propietario (u) y conserva los demás permisos. La salida esperada es El entorno de M00 está listo. Hasta aquí hemos trabajado como root, que no está sujeto a las mismas restricciones de acceso que un usuario normal. En el apartado siguiente crearemos una identidad sin privilegios para comprobar de verdad una lectura permitida y otra denegada.

9. Usuarios y grupos dentro del laboratorio

Hasta ahora has trabajado como root. Para comprobar restricciones de acceso necesitas también un usuario sin privilegios. Un usuario tiene identidad, directorio personal y shell; un grupo permite conceder acceso a varios usuarios sin abrirlo a todos. Cada usuario tiene un grupo principal y puede pertenecer a grupos adicionales.

Las operaciones administrativas siguientes se ejecutan como root dentro de Debian, nunca en el anfitrión. Crearemos una cuenta de laboratorio, pero no cambiaremos el usuario principal del contenedor ni el propietario de todo /bda-m00. Los bloques posteriores seguirán comenzando como root.

Consultar cuentas y crear un usuario

/etc/passwd contiene una línea por cuenta con campos separados por :: nombre, marcador de contraseña, UID, GID principal, información descriptiva, directorio personal y shell. No contiene normalmente las contraseñas: sus hashes se gestionan en /etc/shadow, que no debes mostrar ni incluir en evidencias.

head -n 3 /etc/passwd

Verás cuentas del sistema; algunas no están destinadas a iniciar una sesión interactiva. No edites estos archivos manualmente para crear usuarios.

En Debian, adduser ofrece una creación de cuentas guiada y prepara normalmente el directorio personal. useradd es una herramienta de nivel más bajo: para crear el directorio personal se utiliza expresamente -m. No son intercambiables en todas sus opciones.

adduser --disabled-password --comment "Usuario de laboratorio M00" alumno-m00
id alumno-m00
ls -ld /home/alumno-m00

--disabled-password evita establecer una contraseña y --comment fija la descripción sin preguntas adicionales. La cuenta no se prepara para entrar con contraseña; root podrá abrir su sesión mediante su. Debe existir /home/alumno-m00, con propietario alumno-m00, y id debe mostrar un UID distinto de 0. El valor numérico depende de las cuentas ya existentes. Si la cuenta ya existe porque repites el ejemplo, no intentes crearla de nuevo: consulta id alumno-m00.

Crear un grupo y añadir una pertenencia

groupadd equipo-m00
usermod -aG equipo-m00 alumno-m00
id alumno-m00

groupadd crea el grupo. En usermod, -G establece grupos adicionales y -a añade sin retirar los anteriores. Usar -G sin -a puede eliminar pertenencias que necesitabas conservar. La salida de id debe incluir equipo-m00. Si el grupo ya existe, no vuelvas a crearlo.

Propietario, grupo y acceso real

chown usuario:grupo archivo cambia propietario y grupo; chgrp grupo archivo cambia únicamente el grupo. Ninguna de estas órdenes concede por sí sola permisos de lectura o escritura. Prepara dos archivos de prueba:

mkdir /bda-m00/usuarios
chmod 755 /bda-m00/usuarios
cp data/raw/notas-prueba.txt usuarios/solo-root.txt
cp data/raw/notas-prueba.txt usuarios/compartido.txt
chmod 600 usuarios/solo-root.txt
chown root:equipo-m00 usuarios/compartido.txt
chmod 640 usuarios/compartido.txt
ls -l usuarios
ls -ld /bda-m00

En un montaje que respete estos propietarios y modos, solo-root.txt debe mostrar -rw------- y propietario root; compartido.txt, -rw-r-----, propietario root y grupo equipo-m00. Para llegar a ellos, el usuario necesita también atravesar /bda-m00 y usuarios: comprueba los directorios y las restricciones del anfitrión antes de atribuir un fallo al archivo. Aplica la advertencia sobre permisos de carpetas compartidas del apartado 7.

Abre una sesión con la nueva identidad:

su - alumno-m00
whoami
pwd
id
cd /bda-m00
cat usuarios/compartido.txt
cat usuarios/solo-root.txt

su - alumno-m00 inicia una shell con el entorno de inicio de ese usuario y te sitúa en su directorio personal. whoami debe indicar alumno-m00, pwd inicialmente /home/alumno-m00, e id debe incluir el grupo adicional. Crear la pertenencia antes de abrir esta sesión evita usar una sesión con grupos antiguos.

La lectura del archivo compartido debe mostrar las tres notas. La lectura de solo-root.txt debe fallar por falta de permisos. Este fallo es el resultado esperado: no lo «arregles» con permisos 777. Vuelve a la sesión administrativa:

exit
whoami
cd /bda-m00

Ahora whoami debe indicar root. Este exit cierra la shell creada por su, no el Bash principal; ejecutar otro exit desde la sesión principal sí detendría el contenedor.

Para distinguir un cambio de grupo de un cambio de propietario, sobre la copia de prueba:

chgrp root usuarios/compartido.txt
ls -l usuarios/compartido.txt
chgrp equipo-m00 usuarios/compartido.txt
ls -l usuarios/compartido.txt

El propietario debe seguir siendo root; solo cambia el grupo. Deja finalmente equipo-m00 para conservar el ejemplo de lectura compartida.

Baja de cuentas: qué se elimina y qué permanece

userdel y deluser eliminan cuentas, pero no debes suponer que borrar una cuenta elimina sus archivos. En Debian, deluser ofrece opciones como --remove-home; userdel -r también solicita retirar el directorio personal. Eliminar el directorio personal no equivale a borrar todos los archivos que ese usuario haya creado en otros sitios.

Para practicar una baja sin perder la cuenta del ejemplo, crea una cuenta desechable como root:

adduser --disabled-password --comment "Cuenta desechable M00" temporal-m00
ls -ld /home/temporal-m00
deluser --remove-home temporal-m00
id temporal-m00
ls -ld /home/temporal-m00

Tras la baja, las dos últimas consultas deben indicar que la cuenta y su directorio personal ya no existen. No reutilices este ejemplo con usuarios reales ni con alumno-m00. Para comprobar también una baja de grupo aislada:

groupadd temporal-grupo-m00
groupdel temporal-grupo-m00

Consulta con nano /etc/group y busca el nombre, sin guardar cambios: temporal-grupo-m00 no debe aparecer, mientras que equipo-m00 permanece. Las cuentas y grupos pertenecen al contenedor, no al volumen; si eliminas el contenedor, conservar los archivos no conserva automáticamente estas identidades.

Referencia de opciones específicas de Trixie: manual de adduser.

10. SSH: una terminal en otro equipo

SSH (Secure Shell) permite abrir una sesión cifrada en otro equipo. Hay dos componentes: el cliente, desde el que conectas, y el servidor, que acepta la conexión. Tener el cliente instalado no demuestra que exista un servidor escuchando.

En nuestro laboratorio, docker exec abre una shell mediante Docker y no usa SSH. Ahora instalaremos además un servidor SSH en ese mismo contenedor para conectar desde el anfitrión. Usaremos la cuenta sin privilegios alumno-m00 preparada en el apartado 9, no la cuenta root.

Usuario, dirección, puerto y autenticación

La forma de una conexión es ssh -p puerto usuario@equipo. El usuario es una cuenta del servidor; no tiene por qué coincidir con tu cuenta local. El puerto habitual es 22, pero un laboratorio puede publicar otro. No confundas cambiar el puerto donde escucha el servidor con publicar un puerto de Docker.

El contenedor se ha creado con -p 127.0.0.1:2222:22: SSH escuchará dentro en el 22 y el cliente del anfitrión utilizará el 2222. Publicar solo en 127.0.0.1 limita el acceso al propio equipo; no pretendemos ofrecer SSH a toda la red del aula.

La autenticación puede hacerse con contraseña o con un par de claves. La clave privada permanece protegida en el cliente y nunca se entrega ni se incorpora a Git; la clave pública se autoriza en el servidor. «Entrar sin escribir la contraseña de la cuenta» no significa conectarse sin autenticación, y una clave privada puede estar protegida con una frase de paso.

La primera conexión también comprueba la identidad del servidor mediante su clave de host. La huella debe contrastarse por un canal fiable antes de aceptarla. Un aviso de cambio de clave no se resuelve desactivando esa comprobación ni borrando registros a ciegas.

Instalar y arrancar el servidor en Debian

Mantén abierta la sesión administrativa de Docker. Las siguientes órdenes se ejecutan dentro del contenedor como root:

apt update
apt install -y openssh-server
passwd alumno-m00

openssh-server instala el servidor y sus claves de host. La cuenta se creó sin contraseña en el apartado 9: passwd permite establecer ahora una para esta prueba. Escríbela dos veces cuando se solicite; no se muestra en pantalla. Usa una contraseña de laboratorio, no una que reutilices en servicios personales, y no la incluyas en entregas ni comandos.

Prepara una configuración propia del laboratorio:

nano /etc/ssh/sshd_config.d/m00.conf

Escribe y guarda:

m00.conf

PermitRootLogin no
PasswordAuthentication yes

Son opciones del servidor, diferentes del archivo de configuración del cliente que estudiaremos después. Prohíben el acceso SSH de root y permiten la autenticación con la contraseña de la cuenta de prácticas. No modifiques otros archivos ni elimines reglas existentes.

mkdir -p /run/sshd
/usr/sbin/sshd -t
service ssh start
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub

/run/sshd es un directorio de ejecución del servicio, no un lugar de entrega. sshd -t comprueba la configuración: si es correcta, no muestra nada; si informa de un error, corrígelo antes de continuar. service ssh start arranca el servidor en este contenedor sin presuponer systemd. La última orden muestra la huella de su clave pública ED25519: anótala para contrastarla con el aviso del cliente. No muestra la clave privada.

Después de detener y volver a iniciar el contenedor, repite service ssh start; no se presupone arranque automático. Si cambias la configuración con el servidor ya activo, compruébala con sshd -t antes de aplicar service ssh restart, que reinicia este servicio y puede interrumpir conexiones. Conserva la sesión Docker para no depender de SSH mientras configuras.

Conectar desde el anfitrión

Abre otra terminal del equipo anfitrión, sin cerrar la sesión principal de Docker. Comprueba primero la publicación:

docker port bda-m00-debian 22/tcp

Debe mostrar 127.0.0.1:2222. Si no hay publicación, un docker start no puede añadirla: crea un contenedor correctamente configurado siguiendo la recuperación conservadora de 1.2. Conserva cualquier trabajo previo; el contenedor nuevo necesitará paquetes y cuentas de nuevo, aunque reutilice el volumen. Si 2222 está ocupado, acuerda otro puerto del anfitrión y adapta tanto la creación como la conexión, manteniendo el 22 interno.

El anfitrión necesita un cliente OpenSSH disponible. En macOS/Linux consulta ssh -V; en Windows, usa una terminal con el cliente OpenSSH instalado. La instalación de openssh-client dentro de Debian no instala el cliente del anfitrión.

ssh -p 2222 [email protected]

En la primera conexión, compara la huella del aviso con la obtenida dentro del contenedor antes de aceptar. Si el aviso indica otro tipo de clave, consulta su huella correspondiente con el docente. Después introduce la contraseña de alumno-m00. No desactives la comprobación de identidad para evitar el aviso.

Una vez conectado, las órdenes siguientes se ejecutan en la sesión SSH dentro de Debian:

whoami
pwd
cd /bda-m00
cat usuarios/compartido.txt
exit

Debes ver alumno-m00, su directorio personal /home/alumno-m00 y las tres notas del archivo compartido. exit vuelve al prompt del anfitrión; no detiene el contenedor ni cierra la sesión administrativa de Docker. Si aparece Connection refused, revisa contenedor activo, publicación y arranque del servidor. Si aparece Permission denied, revisa cuenta, contraseña y configuración; no habilites root como solución.

Comprobar otra configuración sin conectarse

Podemos practicar con el cliente sin disponer todavía de un servidor. Desde Debian, comprueba la versión:

ssh -V

La salida identifica OpenSSH. Para preparar una configuración aislada de tu configuración personal:

mkdir /bda-m00/ssh
nano /bda-m00/ssh/config

Escribe:

# config
Host servidor-aula
    HostName 192.0.2.10
    User alumno-m00
    Port 2222

Host define un alias; HostName, la dirección; User, la cuenta remota; y Port, el puerto del cliente. 192.0.2.10 es una dirección de documentación, no un servidor real del aula. Consulta la configuración resultante:

ssh -G -F /bda-m00/ssh/config servidor-aula

-F elige este archivo y -G muestra la configuración efectiva sin abrir una conexión. Localiza hostname 192.0.2.10, user alumno-m00 y port 2222; aparecerán también valores predeterminados. No necesitas contraseña ni acceso de red para esta comprobación. Si la carpeta ya existe, reutilízala: no repitas su creación.

Una conexión real tendría la forma ssh -F /bda-m00/ssh/config servidor-aula, pero no la ejecutes con esta dirección ficticia. Solo se conectará cuando el docente proporcione un servidor, cuenta, dirección y huella reales. Para terminar una sesión SSH se utiliza exit, que cierra la shell remota, no el cliente de Docker que abrió una shell distinta.

SCP: transferir archivos, no abrir una shell

scp copia mediante SSH. La dirección de la copia depende de qué argumento es local y cuál incluye usuario@equipo:ruta. Los siguientes son modelos de sintaxis, no órdenes para ejecutar contra un servidor inexistente:

scp -P 2222 notas.txt usuario@equipo:/ruta/destino/
scp -P 2222 usuario@equipo:/ruta/notas.txt ./notas-recibidas.txt

El primer modelo envía un archivo; el segundo lo recibe. En scp, el puerto usa -P mayúscula; en ssh, -p minúscula. scp -r copia directorios, como cp -r, pero a través de la conexión. No publiques claves privadas ni contraseñas al preparar una transferencia. El acceso remoto, sus permisos y el cifrado no convierten automáticamente la transferencia en una copia de seguridad verificada.

Ejercicios SSH recuperados

ID	Actividad y evidencia
SSH-1	Consulta sin conectarte la configuración preparada y anota alias, usuario, dirección y puerto efectivos. Explica qué prueba y qué no prueba esta consulta.
SSH-2	En una copia de la configuración dentro de /bda-m00/ssh, cambia el puerto a 2200 y comprueba el valor efectivo, sin alterar la configuración original ni intentar conectar.
SSH-3	Para los dos modelos SCP anteriores, identifica origen, destino y equipo donde se escribe cada orden. Explica la diferencia entre clave pública, privada y clave de host, y cómo actuarías ante una huella desconocida.
SSH-4	Conecta desde el anfitrión al contenedor preparado, comprueba identidad y directorio, lee el archivo compartido y cierra solo la sesión remota. Conserva evidencias de la publicación del puerto y de las comprobaciones, sin contraseña ni claves privadas.

La conexión real se limita al mismo contenedor y al anfitrión, con una cuenta de prácticas. La configuración ficticia anterior sigue utilizándose solo con -G; no apunta a este servidor. screen, SSHFS, VPN y acceso desde otros equipos quedan fuera de estos ejemplos.

Ejercicios de refuerzo

Realiza las actividades en el orden de la tabla, dentro del volumen y partiendo de /bda-m00. Los ID conservan la numeración de la propuesta seleccionada. Mantén abierta la sesión principal del contenedor para las actividades 2 y 3. Antes de la actividad 8, prepara la carpeta biblioteca/apuntes dentro del volumen: se utilizará hasta la actividad 13.

ID	Actividad
2	Abre una segunda terminal del mismo contenedor. Crea una carpeta llamada segunda-sesion dentro del volumen desde una sesión y comprueba que aparece en la otra.
3	Cierra la segunda sesión y comprueba que la primera sigue disponible.
5	Crea de una sola vez la estructura practicas/octubre/semana-01 y comprueba que existen todos sus niveles.
8	Crea tres archivos vacíos llamados terminal.txt, permisos.txt y docker.txt dentro de biblioteca/apuntes. Comprueba su tamaño.
10	Escribe con el editor cinco líneas de notas en biblioteca/apuntes/terminal.txt. Guarda el archivo y comprueba su contenido.
11	Consulta únicamente las dos primeras líneas del archivo de notas, sin abrir el editor.
12	Consulta únicamente las dos últimas líneas del archivo de notas.
13	Comprueba cuántas líneas tiene el archivo de notas y contrasta el resultado con su contenido.

Práctica guiada

Dentro de /bda-m00, crea la estructura entregas/octubre, añade un archivo vacío llamado notas.txt y prepara una copia de seguridad denominada notas.bak. Entrega las órdenes ejecutadas y una comprobación que demuestre que existen ambos archivos.

Relación con resultados de aprendizaje y criterios de evaluación

RA / CE	Evidencia
RA0.a)	Navegación, creación, consulta y búsqueda de archivos ejecutadas y verificadas.
RA0.b)	Permisos justificados; usuario y grupo creados, pertenencia verificada y acceso permitido o denegado comprobado con una identidad sin privilegios.