Segundo asalto: aquí ya no se crean archivos, se procesa — pipes, filtros, variables de entorno y los comandos que convierten la terminal en una cadena de montaje. 9 ejercicios (ex00–ex08).
Shell 01 da por sabidas muchas piezas de Unix: cómo viaja el texto de un comando a otro, qué
hace el shell con las comillas y los $, y media docena de herramientas de texto. Aquí
está cada una explicada desde cero, con un ejemplo sacado de los propios ejercicios (las salidas
están ejecutadas). En el resto de la página, la primera vez que sale uno de estos términos en cada
tarjeta lleva un enlace a su entrada.
Todo programa de Unix arranca con tres canales abiertos: la entrada estándar
(stdin, descriptor 0), de donde lee; la salida estándar (stdout, descriptor 1), donde
escribe sus resultados; y la salida de error (stderr, descriptor 2), para los mensajes de
error. Por defecto stdin es el teclado y las dos salidas son la pantalla, pero el shell puede
conectarlos a archivos (>, <) o a otros programas
(|).
Casi todos los comandos del módulo leen de stdin si no les das un archivo: tr,
sed, awk, sort, rev, wc. Por eso
se pueden encadenar. La Moulinette compara lo que tu script deja en stdout.
|)a | b ejecuta los dos comandos a la vez y conecta la salida estándar de
a con la entrada estándar de b: lo que a imprime no sale
por pantalla, lo lee b. Se pueden encadenar tantos como quieras, y a la cadena entera
se la llama pipeline.
$ printf 'b\na\nc\n' | sort -r
c
b
a
Es la pieza central del módulo: ex01 tiene tres etapas y ex07, ocho. stderr no pasa por la tubería; solo stdout.
De dónde viene: la idea es de Doug McIlroy, en Bell Labs; Ken Thompson la añadió a Unix en 1973, junto con la barra vertical para escribirla.
Un programa que lee texto por stdin, lo transforma y escribe el resultado por stdout, sin
preguntar nada ni guardar nada. grep quita líneas, cut se queda con
columnas, tr cambia caracteres, sort ordena, rev invierte.
Cada uno hace una sola cosa, y los problemas grandes se resuelven poniendo varios en fila con
tuberías. Es la llamada filosofía Unix: «escribe programas que hagan una cosa y la hagan
bien, y que trabajen juntos».
\n) y cat -eEl final de una línea no es «nada»: es un byte, el 10 en ASCII, que se escribe
\n. printf 'hola' produce 4 bytes y printf 'hola\n', 5.
Como el salto no se ve, el enunciado pasa las salidas por cat -e, que pinta un
$ en cada final de línea:
$ printf 'hola\n' | cat -e
hola$
Si en un ejemplo el prompt $> aparece pegado a la salida, como en ex01, ex05 y
ex07, es que no hay salto final. La Moulinette compara byte a byte, así que un \n de
más o de menos es un fallo.
/bin/sh y permiso de ejecuciónUn script es un archivo de texto con comandos, los mismos que escribirías a mano, que un
shell (el intérprete de comandos) lee y ejecuta de arriba abajo. Hay varios shells: bash,
zsh, dash… El enunciado pide que los de este módulo funcionen con /bin/sh, el shell
POSIX básico (en Ubuntu, /bin/sh es dash), así que no valen extras propios de bash.
Hay dos maneras de lanzarlo: sh find_sh.sh, que solo necesita poder leerlo, o
./find_sh.sh, como en los ejemplos del enunciado, que además necesita el permiso de
ejecución (chmod +x); sin él da Permission denied. Una primera línea
#!/bin/sh (el shebang) indica con qué intérprete ejecutarlo en ese segundo
caso; si falta, lo ejecuta el mismo shell desde el que lo lanzas. Los scripts de este repo no
lo llevan.
$Una variable de entorno es un par nombre=valor que un proceso hereda del que lo lanzó. Así se
le pasan datos a un script sin argumentos: la Moulinette hace algo como
FT_USER=daemon ./print_groups.sh, y dentro del script $FT_USER vale
daemon.
Escribir $NOMBRE (o ${NOMBRE}) es una expansión: antes de
ejecutar la línea, el shell cambia ese trozo por el valor. Las llaves sirven para marcar dónde
acaba el nombre, como en "${FT_LINE1},${FT_LINE2}p" de ex07, que con
FT_LINE1=7 y FT_LINE2=15 se convierte en 7,15p antes de
llegar a sed. En este módulo se usan FT_USER, FT_LINE1,
FT_LINE2, FT_NBR1 y FT_NBR2.
*, ?)Antes de ejecutar un comando, el shell busca palabras con * (cualquier secuencia
de caracteres) o ? (un carácter cualquiera) y las cambia por los nombres de archivo
del directorio que encajan. Es el propio shell quien lo hace, no el comando. Si nada encaja,
sh deja la palabra tal cual:
$ echo *.sh # en un directorio con a.sh
a.sh
$ echo *.zzz
*.zzz
Por eso en ex02 el patrón va entre comillas, find . -name '*.sh': tiene que
llegarle a find el texto *.sh, no la lista de archivos del directorio
actual. Y por eso el nombre de ex05, lleno de * y ?, no se puede escribir
sin comillas.
Son la manera de decirle al shell «esto no lo interpretes». Hay tres niveles:
'…': nada se interpreta, ni $, ni
*, ni \. La única limitación es que dentro no puede haber otra comilla
simple."…": se siguen expandiendo $ y
$( ), pero no los comodines ni los espacios, y \ solo es especial
delante de $, `, ", \ y el salto de
línea.\ fuera de comillas: protege solo el carácter
siguiente.$ X=42; echo '$X' "$X"
$X 42
Las comillas dobles alrededor de una variable ("$FT_USER") hacen que su valor
llegue entero como un solo argumento aunque tenga espacios o asteriscos. El nombre de ex05 combina
todo: va entre simples, y cada comilla simple del nombre se escribe '\'' (cerrar,
comilla protegida, abrir).
$( )$(comando) ejecuta el comando y pone en su lugar lo que ha impreso (quitando los
saltos de línea del final). Sirve para guardar un resultado en una variable:
$ echo "hoy: $(echo uno dos | tr ' ' '-')"
hoy: uno-dos
En ex08, n1=$(printf '%s' "$FT_NBR1" | sed …) guarda en n1 el número
ya traducido a dígitos normales, para usarlo después en la línea de bc.
^ y $Una expresión regular (regex) es un patrón que describe un conjunto de textos. Lo usan
grep, sed y awk. Las piezas de este módulo: un carácter
normal se representa a sí mismo; . es cualquier carácter; * repite lo
anterior cero o más veces (así que .* es «cualquier cosa»); \. es un
punto de verdad; ^ ancla al principio de la línea y $ al final.
Ejemplos del módulo: ^# son las líneas que empiezan por # (ex07),
\.sh$ es «.sh» justo al final (ex02) y .*/ es todo hasta la última
barra, porque * se come todo lo que puede. Ojo: el * de una regex y el
comodín del shell se parecen pero no son lo mismo.
sed y la sustitución s/…/…/sed (stream editor) aplica órdenes de edición a cada línea que le llega.
La más usada es s/patrón/reemplazo/: cambia la primera coincidencia del patrón; con
g al final (s/…/…/g), todas. Varias órdenes se separan con
;, y el separador / puede ser otro carácter, como |:
$ echo ./sub/file2.sh | sed 's|.*/||; s|\.sh$||'
file2
Con -n no imprime nada salvo lo que se le pida con p:
sed -n '2,3p' saca solo las líneas 2 y 3, que es lo que hace ex07 con
FT_LINE1 y FT_LINE2.
awk: patrón, acción, campos y NRawk es un pequeño lenguaje para procesar texto línea a línea. Un programa awk es
una lista de patrón {acción}: para cada línea que cumple el patrón se ejecuta la
acción. Si falta el patrón, vale para todas; si falta la acción, se imprime la línea. Además awk
parte cada línea en campos separados por espacios: $1, $2… y
cuenta las líneas en NR (number of records).
$ printf ' ether 52:54:00:12:34:56 txqueuelen 1000\n' | awk '/ether/ {print $2}'
52:54:00:12:34:56
$ printf 'uno\ndos\ntres\ncuatro\n' | awk 'NR % 2 == 1'
uno
tres
El primero es ex04 (los espacios del principio no cuentan como campo) y el segundo, ex06.
De dónde viene: el nombre son las iniciales de sus autores, Aho, Weinberger y Kernighan, que lo escribieron en Bell Labs en 1977.
cut)Muchos archivos de texto son tablas: cada línea es un registro y un carácter fijo, el
delimitador, separa sus campos. cut -d: -f1 parte cada línea por
: y se queda con el primer campo:
$ echo 'root:x:0:0:root:/root:/bin/bash' | cut -d: -f1
root
A diferencia de awk, cut no agrupa delimitadores: dos : seguidos son un campo
vacío entre medias. Es lo que hace falta con /etc/passwd.
tr: cambiar o borrar caracterestr (translate) trabaja carácter a carácter, no con palabras ni
patrones. tr 'abc' 'xyz' cambia cada a por x, cada b por y y cada c por z;
tr -d 'abc' borra esos caracteres.
$ echo "a b c" | tr ' ' ','
a,b,c
En ex01 hace las dos cosas: cambia espacios por comas y borra el \n final. En ex07
cambia los saltos de línea por @ para tener todo en una línea, y sed
remata.
find: condiciones y accionesfind recorre un directorio y todos sus subdirectorios y, para cada entrada, evalúa
una expresión. Las condiciones son verdaderas o falsas: -type f (archivo
regular), -type d (directorio), -name '*.sh' (el nombre encaja con el
patrón). Puestas una detrás de otra se unen con «y»; -o es «o». Si no se da ninguna
acción, imprime la ruta de lo que cumple la expresión, una por línea y empezando por el propio
..
Un enlace simbólico no es ni -type f ni -type d (es
-type l), así que ni ex02 ni ex03 lo cuentan.
idUnix identifica a cada usuario con un número (UID) y un nombre. Los grupos son
conjuntos de usuarios que comparten permisos: cada usuario tiene un grupo principal y puede estar
en otros (en Ubuntu, por ejemplo, sudo o adm). id usuario
enseña todo; id -G solo los números de grupo y id -Gn sus nombres,
separados por espacios. En ex01, para FT_USER=daemon el enunciado espera
daemon,bin; la lista depende de cada máquina.
/etc/passwdEl archivo donde Unix guarda la lista de cuentas, una por línea, con siete campos separados por
:: nombre, contraseña (hoy siempre x: la de verdad, cifrada, está en
/etc/shadow), UID, GID, descripción, directorio personal y shell. Puede tener líneas
de comentario que empiezan por # (en macOS, las primeras). ex07 trabaja solo con el
primer campo, el nombre.
Una interfaz es cada punto por el que la máquina se conecta a una red: la tarjeta
Ethernet, el wifi, el lazo local lo, las interfaces virtuales que crean las máquinas
virtuales o Docker. La dirección MAC es el identificador de 48 bits de una interfaz,
escrito como seis bytes en hexadecimal: 52:54:00:12:34:56. Los tres primeros bytes
identifican al fabricante. ifconfig la muestra en la línea que empieza por
ether; lo no tiene.
Una base es cuántos símbolos se usan para escribir números. En base 10 hay diez (0–9) y cada
posición vale diez veces más que la de su derecha; en base 5 hay cinco y cada posición vale cinco
veces más: 10 en base 5 es 5 y 4321 en base 5 es
4·125 + 3·25 + 2·5 + 1 = 586. A partir de base 11 hacen falta símbolos nuevos, y por convención
se usan letras: A = 10, B = 11, C = 12…
Los símbolos son una convención: nada impide usar ', \,
", ?, ! en vez de 0–4. Eso es todo lo que tiene de raro
ex08: el primer ejemplo, traducido, es 10321201 (88926) más 14120222
(145062) en base 5, que suman 233988, que en base 13 se escribe 82671 y, con el
alfabeto de salida, Salut.
bc, la calculadora del shellbc lee operaciones por stdin y escribe el resultado. Trabaja con enteros de
cualquier tamaño y tiene dos variables especiales: ibase, la base en la que lee los
números, y obase, la base en la que los escribe.
$ echo "obase=16; 255" | bc
FF
$ echo "obase=13; ibase=5; 4 + 4" | bc
8
$ echo "ibase=5; obase=13; 4 + 4" | bc
10
La tercera es la trampa: una vez puesto ibase=5, el 13 de
obase=13 se lee en base 5 y vale 8, así que el resultado sale en base 8. Por eso
ex08 fija obase primero. Para bases mayores que 10, bc usa las cifras 0–9 y las
letras A–F.
% (resto)a % b es el resto de dividir a entre b: 7 % 2 = 1,
8 % 2 = 0. Con % 2 se distingue par (resto 0) de impar (resto 1). En ex06,
NR % 2 == 1 selecciona las líneas 1, 3, 5…, y en ex07, NR % 2 == 0,
las 2, 4, 6…
El corrector automático de 42 (en francés, el pasapurés). Tras la evaluación entre pares, ejecuta tus scripts con sus propias variables de entorno y compara la salida con la esperada, byte a byte, sin margen de discusión. Que funcione «en tu máquina con tu usuario» no basta: tiene que dar exactamente la salida pedida con otros datos. Tampoco puede haber en el repositorio archivos que el enunciado no pide.
El único ejercicio sin código: apuntarse al examen del viernes — al evento en la agenda y al proyecto Exam00. El enunciado pide comprobarlo dos veces, y luego tres. No es humor (bueno, no solo): cada piscine hay gente que hace toda la semana de ejercicios y descubre el viernes que no está inscrita en el examen. En 42 la burocracia también es parte del sistema — Vogsphere no perdona.
Mostrar los grupos del usuario indicado en la variable de entorno FT_USER,
separados por comas, sin espacios.
id -Gn "$FT_USER" | tr ' ' ',' | tr -d '\n'
id -Gn usuario — imprime los nombres (-n) de todos los grupos
(-G) del usuario, separados por espacios.tr ' ' ',' — cambia cada espacio por una coma.tr -d '\n' — elimina el salto final: en el ejemplo del enunciado el prompt
aparece pegado a la salida (…libvirt$>), señal de que no hay \n.Primera aparición de dos ideas clave del módulo: los scripts se parametrizan por
variables de entorno (la Moulinette exporta FT_USER antes de ejecutar),
y tr es el transformador de caracteres más barato del sistema.
Buscar todos los .sh del directorio actual y subdirectorios y mostrar solo el
nombre, sin ruta y sin extensión.
find . -type f -name '*.sh' | sed 's|.*/||; s|\.sh$||'
find localiza (./sub/file2.sh) y sed recorta con dos
sustituciones encadenadas: s|.*/|| borra todo hasta la última barra (fuera la ruta) y
s|\.sh$|| borra la extensión anclada al final. Detalle de estilo: usar |
como delimitador de sed evita el baile de contrabarras al trabajar con rutas — el clásico
s/\/ruta\/…// ilegible.
Contar archivos regulares y directorios (incluido .) del directorio actual hacia
abajo.
find . -type f -o -type d | wc -l
find con dos condiciones unidas por -o (OR) emite una línea por
coincidencia — y . siempre es la primera —, y wc -l las cuenta.
El patrón generador | contador es el pan de cada día en Unix: no se cuenta "a mano",
se produce un flujo y se mide. (Guiño del enunciado: la salida de ejemplo es, cómo no,
42.)
Mostrar las direcciones MAC de la máquina, una por línea.
ifconfig | awk '/ether/ {print $2}'
En la salida de ifconfig, cada interfaz física tiene una línea
ether xx:xx:xx:xx:xx:xx …. El one-liner de awk hace las dos cosas a la
vez: /ether/ filtra esas líneas y {print $2} imprime su segundo campo,
la MAC. Es el ejercicio-presentación de awk: patrón + acción, campos ya troceados gratis.
(La alternativa moderna sería ip link | awk '/link\/ether/ {print $2}' —
pero el enunciado manda: man ifconfig.)
Crear un archivo que contenga exactamente 42 (2 bytes, sin salto) y cuyo nombre
sea, literalmente:
"\?$*'MaRViN'*$?\"
$ printf '42' > '"\?$*'\''MaRViN'\''*$?\"'
El nombre es una mina anti-shell: comillas dobles, backslashes, $, *,
? y comillas simples — todo con significado especial. La solución es entender de una
vez el quoting: entre comillas simples nada se interpreta… excepto la
propia comilla simple, que no puede aparecer. El truco '\'' cierra la cadena, mete
una comilla escapada y la reabre. Para Unix el nombre es válido sin más: cualquier byte salvo
/ y NUL puede formar parte de un nombre de archivo. (En Windows/NTFS este archivo
directamente no puede existir — ", * y ? están prohibidos.)
Ejecutar ls -l pero mostrando solo una de cada dos líneas, empezando por la
primera.
ls -l | awk 'NR % 2 == 1'
NR es el número de línea que awk lleva contado. La condición
NR % 2 == 1 (impar) selecciona 1ª, 3ª, 5ª… y, como no hay bloque {…},
awk aplica su acción por defecto: imprimir. Un programa completo en 11 caracteres. La versión
sed equivalente — sed -n 'p;n' — también cabe en un tuit; elegir herramienta es
parte del aprendizaje.
El gran pipeline del módulo. Sobre /etc/passwd: quitar comentarios, quedarse con
una de cada dos líneas (empezando por la segunda), invertir cada nombre de usuario, ordenarlos en
alfabético inverso, quedarse con los que caen entre las líneas FT_LINE1 y
FT_LINE2, unirlos con ", " y terminar con un punto.
grep -v '^#' /etc/passwd | awk 'NR % 2 == 0' | cut -d: -f1 \
| rev | sort -r | sed -n "${FT_LINE1},${FT_LINE2}p" \
| tr '\n' '@' | sed 's/@$/./; s/@/, /g'
Siete etapas, cada una un comando mínimo que hace una sola cosa:
grep -v '^#' — fuera comentarios.awk 'NR%2==0' — líneas pares (la "una de cada dos, empezando por la segunda").cut -d: -f1 — primer campo de cada línea (el usuario; : separa los
7 campos de passwd).rev — invierte cada línea carácter a carácter.sort -r — orden alfabético inverso.sed -n "${FT_LINE1},${FT_LINE2}p" — imprime solo el rango de líneas pedido
(sed acepta rangos numéricos directamente).tr + sed final — sustituye los saltos por un marcador, convierte el
último en . y el resto en ", ".Es la tesis del módulo entero: problemas aparentemente enrevesados se descomponen en filtros triviales conectados por pipes. El enunciado avisa: «sigue los pasos exactamente en el orden indicado» — cambiar el orden de sort y el recorte de rango da resultados distintos.
r_dwssap es passwd_r escrito
del revés: el ejercicio se autodescribe (passwd + reverse). Leer nombres al revés es deporte
nacional en 42.El jefe final. Sumar dos números que llegan en variables de entorno, cada uno escrito en una base inventada, y mostrar el resultado en una tercera base inventada:
FT_NBR1 viene en base 5 con los símbolos ' \ " ? ! (es decir:
'=0, \=1, "=2, ?=3, !=4).FT_NBR2 viene en base 5 con símbolos m r d o c.g t a i o l u S n e m f
(sí, el sexto símbolo es un espacio).n1=$(printf '%s' "$FT_NBR1" | sed "s/'/0/g; s/\\\\/1/g; s/\"/2/g; s/?/3/g; s/!/4/g")
n2=$(printf '%s' "$FT_NBR2" | sed 's/m/0/g; s/r/1/g; s/d/2/g; s/o/3/g; s/c/4/g')
echo "obase=13; ibase=5; $n1 + $n2" | bc \
| sed 's/0/g/g; s/1/t/g; s/2/a/g; s/3/i/g; s/4/o/g; s/5/ /g;
s/6/l/g; s/7/u/g; s/8/S/g; s/9/n/g; s/A/e/g; s/B/m/g; s/C/f/g'
La clave es darse cuenta de que una "base rara" solo es un cambio de alfabeto: con
sed se traducen los símbolos a dígitos normales, bc
(la calculadora de precisión arbitraria de Unix) hace la conversión de bases y la suma de verdad
(ibase=5, obase=13 — el obase se fija primero, cuando aún se lee en
decimal), y un último sed traduce los dígitos del resultado (0–9, A, B, C — así
imprime bc las bases hasta 16) al alfabeto final. Los símbolos elegidos (\,
", ?…) obligan además a repasar el quoting del ex05: escapar el
backslash dentro de un sed dentro de unas comillas dobles tiene su miga
(s/\\\\/1/g).
¿Y los alfabetos no son arbitrarios? El de salida, leído con sus 13 símbolos en orden de valor,
deletrea "gtaio luSnemf" — anagrama de "Salut mon eg…"; de hecho el
primer ejemplo del enunciado da como resultado Salut ("hola" en francés). Todo el
ejercicio está montado para que el resultado salude.
r_dwssap a passwd — hasta el argot del enunciado invierte cosas.Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a donde está
explicado. En Shell 01 casi todo se defiende ejecutando: ten preparada una carpeta de pruebas con
algunos .sh y saber cambiar las variables de entorno en la misma línea del comando.
Están agrupadas en: los comandos, casos límite y entrega. Antes de mirar la respuesta, intenta
contestar tú.
| de print_groups?Conecta la salida estándar de un comando con la entrada estándar del siguiente, y los tres
comandos se ejecutan a la vez. id -Gn escribe los grupos separados por espacios,
el primer tr los recibe y cambia espacios por comas, y el segundo borra el salto de
línea. Solo pasa stdout: los errores siguen saliendo por pantalla.
→ tubería, ex01
Porque el ejemplo del enunciado lo muestra así: el prompt sale pegado a la lista
(…libvirt$>). La Moulinette compara byte a byte y el \n es un byte
más. En cambio find_sh y count_files sí lo llevan: en sus ejemplos con cat -e cada
línea acaba en $. → salto de línea, ex01
sed de find_sh.Son dos sustituciones seguidas, con | como separador para no escapar las barras.
s|.*/|| borra desde el principio hasta la última / (el .*
se come todo lo que puede), y s|\.sh$|| borra .sh solo si está al final.
./sub/file2.sh queda en file2. → sed,
ex02
No, y el enunciado lo avisa. Invertir los nombres antes o después de ordenar cambia el orden
(se ordena toor, no root), y recortar FT_LINE1–FT_LINE2
antes de ordenar se quedaría con otros usuarios. La selección de líneas pares también tiene que
hacerse después de quitar los comentarios, o cambian las parejas. → ex07
obase va antes que ibase?Porque bc lee cada número en la base de entrada vigente. Si primero pones ibase=5,
el 13 de obase=13 se lee en base 5 y vale 8:
echo "ibase=5; obase=13; 4 + 4" | bc da 10 (8 en base 8) en vez de
8. → bc, ex08
'*.sh' entre comillas en find_sh?Para que el patrón le llegue a find sin tocar. Sin comillas, si en el directorio
actual hay un a.sh, el shell cambia *.sh por a.sh antes de
ejecutar, y find . -name a.sh solo encuentra ese: probado en una carpeta con
a.sh, sub/b.sh y sub/x y.sh, sin comillas sale solo
./a.sh. → comodines, ex02
"$FT_USER" con comillas dobles?Para que el valor llegue a id como un solo argumento pase lo que pase. Con las
dobles se sigue expandiendo el $, pero los espacios y los * del valor ya
no se interpretan. Con simples, id recibiría el texto literal $FT_USER.
→ comillas, variables de entorno
.? ¿Y los enlaces simbólicos?El . sí, como pide el enunciado: find lo imprime el primero, porque
es un directorio. Los enlaces simbólicos no: no son -type f ni -type d
sino -type l. Lo mismo pasa con un enlace.sh en find_sh.
→ find, ex03
Porque saca una por cada interfaz con línea ether: la tarjeta de red, el wifi y
también las interfaces virtuales (en un puesto con máquinas virtuales aparece, por ejemplo, una
52:54:00:…, el prefijo de QEMU/libvirt). El lazo local lo no tiene MAC.
El enunciado pide «las direcciones MAC», en plural, una por línea. → MAC,
ex04
42?Con ls -l, que da un tamaño de 2 bytes, o con cat -e, que enseña
42 sin $ al final. Para no tener que escribir el nombre se puede usar un
comodín, como hace el enunciado: ls -lRa *MaRV* | cat -e.
→ comillas, ex05
El enunciado pide que funcionen con /bin/sh, así que nada exclusivo de bash. Si se
lanzan como en los ejemplos, ./find_sh.sh, necesitan permiso de ejecución; con
sh find_sh.sh, no. Ojo: en este repo solo print_groups.sh tiene la
x, los demás están a -rw-r--r--, y ./skip.sh daría
Permission denied. → script
No. El enunciado dice que solo se entregan los archivos pedidos y la Moulinette lo comprueba. Las carpetas de prueba, fuera del repositorio. → Moulinette