Tengo un grupo de máquinas con arranque dual Linux/Windows. Normalmente arrancan con Linux, siendo esta la opción por defecto en el Grub. Hay veces que estoy conectado a ellas de forma remota y quiero arrancar Windows para hacer algún cambio o actualización en dicho sistema.
Podría modificar la configuración de Grub para arrancar con Windows. El problema es que una vez está cambiada no es sencillo revertir el cambio desde el propio Windows y hay que desplazarse hasta la máquina para elegir y configurar manualmente el arranque de Linux. Yo solo quiero arrancar una única vez el Windows y que luego todo siga igual.
La solución es usar el desconocido comando grub-reboot, que permite especificar cual es la opción de arranque por defecto para el siguiente reinicio. Tras ese reinicio, al apagar la máquina todo volverá a su ser habitual y arrancará el sistema por defecto que hayamos tenido habitualmente.
Lo primero es saber como identificar la opción de arranque a programar:
# grep -e "menuentry\ " -e "submenu" /boot/grub/grub.cfg
menuentry 'Ubuntu'.....
submenu 'Opciones avanzadas para Ubuntu' ...
menuentry 'Ubuntu, con Linux 4.15.0-54-generic' ...
menuentry 'Ubuntu, con Linux 4.15.0-54-generic (recovery mode)' ...
menuentry 'Ubuntu, con Linux 4.15.0-20-generic' ...
menuentry 'Ubuntu, con Linux 4.15.0-20-generic (recovery mode)' ...
menuentry 'Windows 7 (en /dev/sda1)' ...
menuentry "Clonezilla live 2.5.5.38" ...
menuentry "Arranque por red: PXE" ...
El comando grub-reboot admite un parámetro numérico (empezando por 0, que identifica la posición en la lista), dos o más números separados por > (para indicar posiciones dentro de submenús, por ejemplo 1>2) o un texto con la etiqueta de la opción de arranque. Por ejemplo, para programar el arranque del Windows 7 haríamos:
# grub-reboot 'Windows 7 (en /dev/sda1)'
# reboot
Y ya está, el sistema se reinicia y arranca en Windows. Podemos conectar a él con rdesktop y hacer nuestras cosas. Cuando ese Windows se apague volverá a arrancar en Linux. Bueno, ayer 25 de julio SpaceX consiguió elevar sin anclajes hasta una altura de 20 metros la StarHopper, el prototipo de la nave que permitirá poner humanos en la Luna y Marte en el futuro.
Prueba superada. Todo listo para pasar a la siguiente fase.
El tener muchos portátiles iguales facilita que cuando la batería de uno de ellos se degrada y empieza a funcionar peor podemos comparar entre ellos e identificar las que están degenerando de una forma real.
Como en nuestro caso la garantía de los contratos cubre la batería durante varios años hemos pensado en cómo hacer una revisión de algunos modelos que daban signos de agotamiento, con el objeto de que nos cambien las baterías defectuosas antes de que expire la garantía.
En mi caso son portátiles Inves Helio-1106L, que son remarcados de Clevo W310CZ (y que se vende con otros etiquetados como Stone N120, Zoostorm 7270-9062, ...). Todos son el mismo.
1. Un poco de teoría de baterías.
Las características de una batería se definen por los mAh y el voltaje. Por ejemplo, para nuestros portátiles Inves tenemos baterías de 2800mAh y 14.8V, como se puede apreciar en la pegatina que traen (los Clevo originales traían baterías de 2200mAh, pero seguramente fueron ampliadas por requisitos del contrato, las cuales pedían una duración de 4 horas de uso medio según diversos tests).
Multiplicando ambos valores obtenemos la capacidad de energía acumulada, que sería 2.800*14.8=41.440wh. Eso significa que si el portátil consume de promedio 11w encendido, con 41.4wh tiene para 41.4/11=3.76 horas de funcionamiento. Con el tiempo y los ciclos de carga-descarga esa capacidad va mermando y es ese porcentaje de merma lo que queremos medir.
Para saber en tiempo real los datos de la batería usamos el comando upower. Cojo un portátil Inves cualquiera, lo cargo al 100% y con él enchufado a la corriente hago:
Lo interesante: la capacidad por diseño de batería es 41.44wh. La capacidad real actual con la batería llena es de 30.08wh, por lo que la capacidad real en este momento es un 72% de la original. En nuestro caso la batería se considera averiada a efectos de garantía si está por debajo del 30%, por lo que de momento se libra de ser cambiada. De esta forma chequearemos todos los portátiles que deseemos.
Si nuestra batería tiene una ruta de acceso distinta de /org/freedesktop/UPower/devices/battery_BAT0 la podemos averiguar con:
# upower -e | grep BAT
2. Testeando la batería.
Una vez embarcado en esto, se me ha ocurrido chequear la bateria durante un ciclo de descarga, para hacerme una idea de su estado, duración y comprender el proceso de drenaje. Los datos que tomaré serán:
Con los que haré un bucle que cada minuto guarde ese resultado en un log hasta que el portátil se apague por falta de energía. Para conseguir simular un uso continuo y exhaustivo desconectaré el apagado de pantalla (con xset), pondré el brillo al máximo (con xrandr), simularé mover el ratón cada minuto para evitar entradas en modo ahorro de energía (con xte) y mientras tanto reproduciré un vídeo de youtube de varias horas de duración conectado a la red wifi.
Este es el sript check-bateria.sh
#!/bin/bash
xset s off -dpms
while true
do
xrandr --output eDP-1 --brightness 1.0
xte 'mousermove 4 4'
date >> ~/log-bateria.txt
upower -i $(upower -e | grep 'BAT') | grep -E "state|to\ full|percentage|energy" >> ~/log-bateria.txt
sleep 60
xte 'mousermove -4 -4'
done
exit 0
Los pasos a seguir son encender el portátil con la batería cargada al 100%, iniciar sesión, conectar la wifi, iniciar el vídeo de Youtube y ejecutar el script anterior, dejando todo en marcha hasta que el portátil se apague.
El consumo instantáneo (energy-rate) está entre 15 y 17.5 watios de promedio. Con 30.0884wh de capacidad aguantaría una hora y 48 minutos de uso continuo intensivo = 1.8 horas expresado en valor decimal.
Con los 41.44 Wh iniciales nos daría dos horas y media de uso intensivo, 2.5 horas en valor decimal.
Según upower la batería está en el 72,6071% de su capacidad inicial de fábrica. Para cotejar con la realidad hallamos la razón de las duraciones con el cociente 1.8/2.5 = 0.72. Correcto, coincide con lo estimado por upower.
Como la batería aún retiene un 72% de su capacidad de carga inicial no podemos reemplazarla usando la garantía. Bueno, otra vez será.
Ayer día 22 la India lanzó la nave Chandrayaan 2 en dirección a la Luna, con la intención de aterrizar un rover y convertirse en el cuarto país en la historia que ha puesto de forma controlada una sonda de exploración en la superficie de nuestro satélite.
Esto lo hace sin asistencia de ningún otro país, con su programa espacial propio y de forma autónoma.
El coste de la misión es de 126 millones de euros. El coste de una repetición de elecciones en 2019 en el Reino de España sería superior a los 140 millones de euros. Como vemos, cada uno hace lo que puede según su capacidad.
En esta entrada contamos como instalar el sistema DRBL en un PC con Debian 9 para servir imágenes de Ubuntu 18, imágenes duales y variadas. En dicho post enumeré los pasos para partiendo de un Debian Stretch llegar a tener un servidor DRBL, pero por precaución he hecho una imagen Clonezilla (versión clonezilla-live-2.5.5-38) de todo el sistema instalado por si se me va el portátil que uso como servidor para la clonación multicast.
La imagen es una imagen de partición sda1 y se restaura por tanto usando Clonezilla con la opción "restore part". Si deseamos clonarla sobre una partición distinta a sda1 el propio clonezilla en sus versiones modernas nos permite elegir la partición donde cargarla (por si queremos tener un equipo con arranque dual, con otro sistema para su uso diario y un DRBL para cuando queramos clonar) A su vez dentro contiene la imagen /home/partimag/miniportatiles-xubuntu-13062018 que usamos en nuestros centros. Después podremos poner en /home/partimag todas la imágenes adicionales que necesitemos.
La contraseña de root del sistema DRBL es "linex".
Una profesora me pidió este curso escribir un programa para realizar capturas de pantalla de los escritorios de los alumnos de forma periódica. El objetivo era tener en su carpeta personal una colección con las capturas de pantalla realizadas cada X minutos de los PC de todos los alumnos del aula, para controlar a posteriori el trabajo que habían estado haciendo durante la clase.
Capturar la pantalla desde un script no es complicado, aunque si quieres hacerlo de forma remota y traerlo al ordenador del profesor hay que afinar un poco la cosa.
Como paso imprescindible e inicial es obligatorio que entre el ordenador del profesor y los de los alumnos exista una relación de confianza ssh que nos permita conectar desde la cuenta de root del PC del profesor sin necesidad de introducir contraseña. Tras generar y copiar las claves, en /root/.ssh/id_rsa y /root/.ssh/id_rsa.pub del profesor tendremos las claves pública y privada, mientras que en /root/.ssh/... de los alumnos tendremos la clave privada.
Una vez resuelto el problema de la comunicación entre profesor y alumnos, tenemos que pensar en los posibles escenarios que nos encontramos en nuestras aulas:
Aula aislada: profesor y alumnos están una red privada con rango de direcciones propio, mediante una VLAN creada en el switch. En mi caso con los alumnos tienen direccionamamiento 192.168.0.200-253, sin importar si se usan portátiles o equipos de sobremesa.
Aula integrada: profesor y alumnos no están aislados, si no que usan direcciones públicas de la red del centro. Hay que encontrar una manera de que el PC del profesor sepa a priori cuales son las IP de los PC de alumnos que dependen de él. Esta manera consiste en definir en el fichero /etc/escuela2.0 (el que usamos para configuraciones de nuestras máquinas) una variable llamada IES_IP_ALUMNOS, en la cual indicamos en rango de IP donde están los PC de los alumnos, por ejemplo: 172.23.241.70-85. El valor tomado por defecto es 192.168.0.200-253
Thinclients: en este caso también es un aula aislada, con direcciones del rango 192.168.0.200 en adelante, pero con una particularidad consistente en que con los thinclients las sesiones de los alumnos se ejecutan en el PC del profesor, en una sesión privada en la que la captura de pantalla se hace de una forma diferente. Para saber si el aula tiene thinclients usaremos la variable IES_ISLTSP de /etc/escuela2.0
Aparte de eso, la aplicación debe tener un interface gráfico sencillo para el usuario. Por esta razón he optado por hacer la aplicación de captura usando python e interface gráfico Qt con PyQt5. Para ello uso Qt Designer para diseñar el interface gráfico y Geany para escribir el programa.
Una vez implementado, los ficheros necesarios son distribuidos por la siguiente tarea puppet:
Como vemos la tarea instala varios paquetes necesarios, copia los ficheros y añade una linea a sudoers para permitir a los miembros del grupo teachers ejecutar el programa con permisos de root (necesario para acceder a los pc de los alumnos).
Vamos primero el código del programa principal:
# cat xubuntu18_photomaton/files/photomaton.py
#!/usr/bin/python3
from photomaton_ui import *
import sys
import socket
import subprocess
import os, errno
from datetime import datetime
import paramiko
Para acabar un pequeño detalle: en las au
import time
from configobj import ConfigObj
import psutil
import nmap
class MainWindow(QtWidgets.QMainWindow, Ui_Photomaton):
def __init__(self, *args, **kwargs):
QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
self.setupUi(self)
#Conectamos los botones con los eventos
self.iniciarCaptura.clicked.connect(self.capturar)
self.visualizarCapturas.clicked.connect(self.visualizar)
self.finalizar.clicked.connect(self.finalizarApp)
#Definimos el entorno, creando el directorio destino y leyendo escuela2.0
hostname = socket.gethostname()
#Como se llama usando sudo, el usuario original está en SUDO_USER
try:
self.user=os.environ["SUDO_USER"]
except Exception as e:
print("No eres usuario sudo. Abortando")
#self.user="root"
sys.exit(0)
home = os.path.expanduser("~"+self.user) #Directorio $HOME del usuario
self.pathcapturas=home+"/capturas/"+hostname
config = ConfigObj("/etc/escuela2.0")
self.uso=config.get('USO') #infolab/siatic/...
self.isltsp=config.get('IES_ISLTSP') #true si tiene thinclients
self.ip_alumnos=config.get('IES_IP_ALUMNOS') # Rango de ip de los alumnos, para aulas de workstations.
self.capturando=False
if self.ip_alumnos is None or self.ip_alumnos == "" :
self.ip_alumnos="192.168.0.200-253" # Rango por defecto en aulas con vlan
try:
comando="su "+self.user+" -c 'mkdir -p "+self.pathcapturas+"'"
os.system(comando)
except FileExistsError:
# directory already exists
pass
def finalizarApp(self):
if self.capturando == False:
sys.exit(0)
else:
self.capturando=False
def visualizar(self):
comando="su "+self.user+" -c 'nohup thunar "+self.pathcapturas+" &'"
os.system(comando)
def capturar_ip(self, ip):
s = socket.socket() #Quizá esto se podria quiar, el ssh_client.connnect ya tiene timeout
s.settimeout(30)
address = ip
port = 22
try:
#Intenta conectar por ssh a ver si la IP acepta peticiones ssh
s.connect((address, port)) #Si falla se va a la excepcion
s.close()
#Conectamos por ssh y ejecutamos el comando de captura.
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(ip, 22, 'root', key_filename="/root/.ssh/id_rsa" , timeout=30)
fecha=datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
sleeptime = 0.001
comando='rm -f /tmp/captura.jpg; pc=$(hostname); user=$(who | grep "(:0)" | head -1 | cut -f1 -d" "); test -n "$user" && (su $user -c "DISPLAY=:0 import -window root /tmp/captura.jpg"; chmod 777 /tmp/captura.jpg; echo -n $pc/$user)'
#print("Ejecutando "+comando)
ssh_transp = ssh_client.get_transport()
chan = ssh_transp.open_session()
chan.setblocking(0)
outdata=""
chan.exec_command(comando)
while True: # Hay que esperar a que acabe el comando
while chan.recv_ready():
outdata += chan.recv(1000).decode('ascii')
if chan.exit_status_ready(): # If completed
break
time.sleep(sleeptime)
#Como salida se devuelve "pc/usuario"
signatura=outdata
#Aprovechando la conexion ssh se usa sftp para recuperar el fichero /tmp/captura.jpg y guardarlo en la ruta de destino
sftp = ssh_client.open_sftp()
destino=self.pathcapturas+"/"+signatura
try:
comando='su '+self.user+' -c "mkdir -p '+destino+'"'
os.system(comando)
except FileExistsError:
pass
fichero=destino+"/"+fecha+".jpg"
sftp.get("/tmp/captura.jpg", "/tmp/captura-local.jpg") #Traemos el fichero a local
comando='su '+self.user+' -c "cp /tmp/captura-local.jpg '+fichero+'"'
#print("Ejecutando "+comando)
os.system(comando)
# Cerramos todo lo abierto
ssh_transp.close()
sftp.close()
ssh_client.close()
except Exception as e:
print("Error "+str(e))
def capturar_thinclients(self):
#Obtenemos la lista de usuarios conectados en el servidor de aula, filtramos por aquellos que están conectados con la ip 192.X.Y.Z (thinclients)
for usuario in psutil.users():
if usuario.host[:4] == "192." :
try:
#Sacamos el home del usuario con getent
comando="getent passwd "+usuario.name
process = subprocess.Popen(comando.split(), stdout=subprocess.PIPE)
output, error = process.communicate()
home_user=output.decode("ascii").split(":")[5]
#Conectamos con el thinclient para sacar el hostname
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(usuario.host, 22, 'root', key_filename="/root/.ssh/id_rsa", timeout=30)
fecha=datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
sleeptime = 0.001
comando='cat /etc/hostname | tr -d "\n"'
ssh_transp = ssh_client.get_transport()
chan = ssh_transp.open_session()
# chan.settimeout(3 * 60 * 60)
chan.setblocking(0)
outdata=""
chan.exec_command(comando)
while True: # Hay que esperar a que acabe el comando
while chan.recv_ready():
outdata += chan.recv(1000).decode('ascii')
if chan.exit_status_ready(): # If completed
break
time.sleep(sleeptime)
host=outdata
# Cerramos todo lo abierto
ssh_transp.close()
ssh_client.close()
#Ejecutamos el comando de captura de la sesión del usuario. Se usa os.system porque para comandos complejos es mejor que subprocess.popen
comando='su '+usuario.name+' -c "DISPLAY='+usuario.host+':7 XAUTHORITY='+home_user+'/.Xauthority import -window root /tmp/capture.jpg"'
os.system(comando)
#Copiamos la captura a la carpeta destino
destino=self.pathcapturas+"/"+host+"/"+usuario.name
try:
comando='su '+self.user+' -c "mkdir -p '+destino+'"'
os.system(comando)
except FileExistsError:
pass
fichero=destino+"/"+fecha+".jpg"
comando='su '+self.user+' -c "cp /tmp/capture.jpg '+fichero+'"'
os.system(comando)
comando='rm -f /tmp/capture.jpg'
os.system(comando)
except Exception as e:
pass
def capturar(self):
try:
segundos=int(self.intervaloCaptura.text())*60
except ValueError:
segundos=0
self.capturando=True
self.iniciarCaptura.setText("Capturando...")
self.finalizar.setText("Parar captura")
self.iniciarCaptura.setEnabled(False)
while self.capturando == True:
self.iniciarCaptura.setText("Capturando...")
self.iniciarCaptura.setEnabled(False)
self.do_captura()
if segundos == 0:
break
else: #Espera activa hasta la próxima captura
for i in range(segundos):
time.sleep(1)
app.processEvents()
if self.capturando==False: break
self.iniciarCaptura.setEnabled(True)
self.iniciarCaptura.setText("Iniciar Captura")
self.finalizar.setText("Finalizar")
self.capturando=False
def do_captura(self):
app.processEvents()
#print("Inicio captura")
if self.isltsp == "true":
self.capturar_thinclients()
else:
nm = nmap.PortScanner()
nm.scan(self.ip_alumnos, '22')
for ip in nm.all_hosts():# Equipos conectados, up.
#print("Procesando "+ip)
if nm[ip]['tcp'][22]['state']=="open":
#print("Puerto ssh abierto")
self.capturar_ip(ip)
app.processEvents() # Para procesar clicks de raton durante el bucle.
app.processEvents()
#print("Fin captura")
if __name__ == "__main__":
app = QtWidgets.QApplication([])
window = MainWindow()
window.show()
app.exec_()
Como se puede apreciar es un código python que utiliza clases de conexión ssh para ejecutar en remoto los comandos bash de captura de sesión y traer los ficheros con la captura al home del usuario en el PC del profesor.
El fichero photomaton.jpg contendría la imagen:
Seguimos con el fichero .desktop, el acceso directo para poner en el menú principal y en el escritorio. Nótese el uso de "gksu" para ejecutar como root el programa photomaton.py.
Un vez distribuidos los ficheros con la tarea puppet el modo de funcionamiento es lanzarlo en el ordenador del profesor y ejecutarlo para conectar a los equipos de alumnos detectados como encendidos y realizar las capturas. La pantalla es:
En "Intervalo de capturas (min)" indicamos cada cuanto tiempo queremos hacer las capturas de pantalla. Si dejamos 0 solo se realiza una captura en el momento en que damos al botón "Iniciar Captura".
Mientras que está realizando las capturas el botón "Iniciar Captura" se desactiva. El proceso de captura para pulsando el botón "Parar Captura". A veces tarda un rato en responder ya que no se puede interrumpir mientras está ejecutando la conexión con uno de los clientes.
El botón "Visualizar Capturas" nos lleva al directorio donde se realizan las capturas para que veamos las imágenes. Las capturas se estructuran en directorios separados según el patrón: ~/Capturas/$pc_profesor/$pc_alumno/$login_alumno/*.jpg
Los nombres de ficheros jpg nos indican la fecha y hora de captura:
Y ya está. Con este sistema el profesor puede realizar un seguimiento desatendido completo de la actividad de los alumnos. No solo eso: nosotros también desde nuestro PC podremos realizar seguimiento de ordenadores de uso público del centro.
Ahora que con la magnífica serie Chernobyl (quizá desvirtuada con algunos elementos de ficción y drama innecesarios, en detrimento de otros más interesantes como la construcción del sarcófago y los biorobots) se ha reavivado el tema, dejo varios enlaces sobre accidentes nucleares bastante silenciados:
Three Mile Island: o como "refrigerar" un reactor con vapor de agua en lugar de con agua líquida durante horas hasta fundir parcialmente el núcleo y no darse cuenta.
Vandellós I: o cómo quedarte a dos grados de explotar, mientras que el director de la central se iba a por tabaco en helicóptero a Barcelona y los trabajadores conseguían controlar la temperatura in extremis con el único turbosoplante que no se había parado por inundación.
Lucens: o cómo los suizos se lo intentan montar por su cuenta y funden un reactor el día de su puesta en funcionamiento. La única idea buena: como por si las moscas lo hicieron debajo de una montaña, solo se contaminó ésta.
Por supuesto, recomiendo todos los artículos de Yuri sobre Chernobyl:
Ahora que llegan las vacaciones viene bien dar un repaso a todos los portátiles de los alumnos: ejecutar puppet, pkgsync, limpiar los usuarios cacheados,... No solo eso, también durante el curso de vez en cuando nos toca actuar sobre todos los portátiles de un armario para aplicar alguna configuración que nos han pedido o que soluciona un bug pendiente.
Hasta ahora para tener conectividad tras encender los portátiles había 2 alternativas:
Conectarlos por red cableada a las tomas del suelo o un switch del aula.
Iniciar sesión en cada uno de ellos y conectarlos manualmente a la red Wifi del aula.
Evidentemente ambas opciones son bastante reiterativas y aburridas. Lo ideal sería que para estos casos los portátiles se conectasen de forma autónoma a una red wifi y nosotros pudiesemos manejarlos de forma masiva con tmux-cssh.
Y esa es la idea de este post: basándome en un script de conexión que usa en su centro nuestro compañero Esteban lo he adaptado para que se conecte de forma autónoma a una red wifi concreta predefinida tan pronto como la detecte.
El código del script es (nota: he corregido algunas erratas en el script el 8/10/2019):
# cat /usr/local/bin/conecta-default-wifi
#!/bin/bash
idioma=$LC_ALL
export LC_ALL=C
wifi_maestra="WIFI_AULAS"
wifi_key="a12345678"
nombre_conexion="ies"
activado=$(nmcli radio wifi)
if [ "$activado" != "enabled" ]
then
nmcli radio wifi on #activamos la wifi si no lo esta
fi
conectado=$(nmcli dev status | grep wifi | grep -w -e 'connected' -e "conectado" | awk ' {print $4}')
if [ "$conectado" != "$nombre_conexion" ] # Si no estamos conectados a la wifi maestra...
then
definida=$(nmcli con | grep wifi | grep -w "$nombre_conexion") #Si ya se definió la conexión en network manager la quitamos, para crearla de nuevo cuando nos conectemos
if [ -n "$definida" ]
then
nmcli con delete "$nombre_conexion"conecta-default-wifi
fi
detectada=$(nmcli -f SSID,BSSID,SIGNAL,SECURITY dev wifi list | grep -w "$wifi_maestra")
if [ -n "$detectada" ] # Si la wifi maestra está al alcance....
then
#Si la wifi maestra está al alcance y no estamos en ella, conectamos automaticamente.
nmcli dev wifi con "$wifi_maestra" password "$wifi_key" name "$nombre_conexion"
#Si ya existiese la conession podriamos hacer: nmcli con up $ssidconfigurado
fi
fi
export LC_ALL=$idioma
exit 0
Por tanto tenemos un script y una tarea cron que lo llama cada 3 minutos. El script hace lo siguiente:
Configuramos parámetros para una red wifi con SSID "WIFI_AULAS", una clave fija y un nombre de conexión "ies" para el Network Manager.
Si la tarjeta wifi está apagada en Network Manager, se enciende.
Si la wifi está conectada a un punto wifi, mira si el nombre de la SSID es "WIFI_AULAS". En caso afirmativo, finalizamos el script y no continuamos en los pasos siguientes.
Si existe alguna conexión en Network Manager con el nombre "ies", la borramos. Esto es simplemente para hacer limpieza si ya nos habíamos conectado antes.
Escaneamos las redes wifi circundantes en busca de "WIFI_AULAS". Si la encontramos a nuestro alcance nos conectamos a ella creando una conexión "ies" en Network Manager.
Todo esto se repite cada 3 minutos, de tal forma que tan pronto aparezca en el espectro radioeléctrico la wifi "WIFI_AULAS" el portátil se conectará a ella, desconectando de cualquier otra red wifi en la que estuviera enlazado y permaneciendo conectado mientras esté a su alcance.
Con esto el trabajo queda reducido a llegar al aula con un punto wifi (vale cualquier punto de acceso portátil, incluido un router casero de ADSL) configurado con WIFI_AULAS y la clave indicada, enchufarlo a un punto de red cableado, sacar los portátiles del armario y encenderlos.
En pocos minutos todos estarán conectados a la wifi sin ninguna actuación por nuestra parte y con tmux-cssh o ssh podremos controlarlos. Incluso si tenemos puppet y pgksync en modo automático se ejecutarán sin que tengamos que hacer nada. El punto de acceso solo lo usaremos cuando queramos trabajar de esta manera. El resto del tiempo estará apagado y guardado.
Debido a que te encuentras que la gente mas insospechada se niega a creer la gesta del Apolo XI, ahí va el documental definitivo:
Tras la llegada de los portátiles Techcomputer TC11 he liberado un par de docenas de antiguos miniportátiles MSI L1350D y APD P10ALD. Son aparatos bastante antiguos y justitos (ambos con Intel Atom CPU N455 y 2GB de RAM) que ya daban problemas de usabilidad con Ubuntu 18.
Como he hecho en otros equipos obsoletos con buen resultado, probé a instalar FreeBSD/TrueOS pero la verdad es que no he notado mejora significativa. Pienso que la causa pudiera ser el limitado soporte a la tarjeta gráfica Intel que traen.
Luego probé con varias versiones de Android-x86 con idéntico resultado. Estaba a punto de probar Manjaro pero recordé que tenía pendiente testear una distribución que convierten un portátil en un ChromeBook, que es un sistema operativo ligero cuyo escritorio es un navegador Chrome y por tanto solo permite ejecutar dicho software y los plugins que instalemos en él. En algunos centros educativos están empezando a llegar este tipo de equipos. En otros países se usa masivamente en entornos educativos.
De esta manera tenemos un ordenador en el que hacemos login con las credenciales de Google y que solo permite trabajar con el navegador, en la nube (con Google Docs, Google Drive y las extensiones que instalemos de Chrome Web Store).
Por supuesto, el sistema Chrome OS es propietario de Google y no es fácil instalarlo en un equipo que no sea un ChromeBook certificado. Afortunadamente han salido clones y alternativas que remedan bastante bien el espíritu de Chrome OS. Aunque hay varios donde elegir me he decantado para probar por CloudReady en su versión Home (traducido: la gratuita). Tiene también buena pinta este desarrollo chino, ahora que Trump está en guerra comercial con China.
1. Descarga.
Lo descargamos de la página de Neverware. En caso de duda se descarga la imagen en un .zip para OSX. Lo descomprimimos y dentro hay un fichero .bin con la imagen de disco de arranque. La grabamos a un pendrive USB con:
sudo dd if=cloudready.bin of=/dev/sdX bs=4M
Luego reiniciamos el pc y arrancamos con el pendrive. La instalación comenzará.
2. Instalación.
Durante la instalación se borrará el disco completo, no es sencilla una instalación dual. Lo cierto es que CloudReady construye un sistema infernal basado en mas de 20 particiones, la causa al parecer es algo que viene de serie en Chromium OS. Esta estructura no es algo normal en Linux, pero si lo he visto muchas veces en Android.
La primera pantalla de instalación, con la bienvenida y la elección de idioma:
Luego nos pide una cuenta de gmail.com. Esta cuenta será la propietaria ("owner") del sistema instalado y nunca podrá borrarse. Por ello lo mejor es usar en la instalación una cuenta gmail.com genérica que nos permitirá entrar luego el pc. Una vez instalado todo el sistema, cualquier persona que tenga una cuenta de Gmail podrá iniciar sesión libremente sin problema (o usar una cuenta temporal de invitado, si no tiene/quiere usar su cuenta de gmail).
Evidentemente, para que esta cuenta pueda ser validada es necesario que el ordenador esté conectado a Internet, ya sea por cable o wifi. Esto es un imperativo siempre presente un Chromebook: un sistema diseñado para trabajar en la nube necesita Internet constante.
Por último nos pide el idioma de instalacion:
3. Configuración y uso.
Una vez instalado, el sistema reinicia y aparece la pantalla de login con varias posibilidades:
Iniciar sesión con la cuenta del propietario.
Iniciar sesión con una cuenta válida de Gmail, la cual quedará cacheada para futuros logins offline.
Iniciar sesión con una cuenta de invitado, que al cerrar sesión no quedará rastro en el disco duro local de su actividad.
Borrar una cuenta de las creadas, excepto la de invitado y propietario.
Conectar a una red wifi, necesario para poder iniciar sesión con cuentas de gmail no cacheadas.
Esta es la configuración desde la pantalla de login:
Y esta una pantalla con ya dos cuentas de gmail cacheadas:
Una vez iniciada sesión carga el Google Chrome como única aplicación:
Este sería menú de opciones de la derecha de la barra de tareas:
Y este el menú de la izquierda de la barra:
Si entramos en la configuración vemos las preferencias usuales del Google Chrome, mas varias opciones extra referidas al escritorio de CloudReady:
Comprobando el rendimiento podemos afirmar que no va nada mal. Al tener un Linux subyacente con drivers actualizados y un escritorio con Chrome y sus extensiones de la Chrome Web Store todo va bastante ligerito teniendo en cuenta la poca potencia de esta máquina.
4. Configuración final e imagen Clonezilla para clonar.
Debajo de esto hay un Linux, por lo que podemos acceder a un terminal para configurar otros aspectos. Con la combinación de teclas CTRL-Alt-T entramos en el terminal, llamado "crosh". Una vez dentro con el comando "shell" entramos en una shell parecida a bash.
Las credenciales por defecto para trabajar son chronos/chronos. Si queremos cambiar la contraseña los pasos son:
# sudo mount -o rw,remount /
# sudo passwd chronos
# sudo mount -o ro,remount /
Y después reiniciamos.
Otra cosa que me resulta útil es desactivar la suspensión. Los pasos, tras entrar en el terminal:
# shell
# sudo su
# disable_verity
Reiniciamos la máquina y repetimos los anteriores comandos una vez. Luego hacemos
Aquí tenemos bastante soporte y trucos de configuración adicionales.
Una vez tenemos configurado es el momento de hacer una imagen con clonezilla para instalarlo en otros equipos. La creación de la imagen se inicia normalmente, pero al llear a la partición sda16 siempre aborta con este mensaje:
Starting to clone device (/dev/sda16) to image (-)
Reading Super Block
memory needed: 28369449 bytes
bitmap 7397925 bytes, blocks 2*10485760 bytes, checksum 4 bytes
Calculating bitmap... Please wait...
extfsclone.c: bitmap free count err, partclone get free:57578015 but extfs get 57553763.
Please run fsck to check and repair the file system
Failed to use partclone program to save or restore an image!
Tras muchas pruebas solo puedo afirmar que CloudReady al apaar el sistema siempre deja la partición sda16 en ese estado, provocando un error al crear la imagen. La solución es arrancar clonezilla y, antes de empezar a hacer nada, irnos a un terminal y teclear:
# sudo fsck -a /dev/sda16
Después de esto ya podemos realizar la imagen sin problema. La restauración funciona correctamente.
Esta semana los camaradas chinos nos han sorprendido lanzando un cohete Larga Marcha 11 desde una plataforma marítima.
Espectacular. Con este sistema resulta mucho mas barato y eficiente el envío de satélites.
Ya vimos en su día como configurar un musthave lo mas pequeño posible. Como ahora estoy configurando los portátiles y algunos equipos nuevos, si quiero dejarlos preparados para pkgsync en primer lugar tengo que generar un musthave a partir de los paquetes instalados y luego purgarlo de paquetes dependientes para quedarlo con el menor tamaño posible. Por ello he unificado ambos procesos en un único script:
# cat genera-musthave-minimo.sh
#!/bin/bash
FICHERO=$HOME/musthave.$HOSTNAME
echo "Generando lista de paquetes instalados en $FICHERO..."
aptitude show "?installed ?not(?priority(required)) ?not(?essential) ?not(?automatic)" | grep -e ^Package -e ^Paquete | cut -f 2 -d " " | sort > $FICHERO
echo "Obteniendo lista de paquetes multiarch..."
aptitude show "?installed ?multiarch(same)" | grep -e ^Package -e ^Paquete | cut -f 2 -d " " > /tmp/same
sort -u -o /tmp/same /tmp/same
echo "Procesando lista de paquetes multiarch..."
for paquete in `cat /tmp/same`
do
sed -i 's|$paquete||' $FICHERO
dpkg -l|grep "$paquete:i386" 1>/dev/null && echo "$paquete:i386" >> $FICHERO
dpkg -l|grep "$paquete:amd64" 1>/dev/null && echo "$paquete:amd64" >> $FICHERO
done
sort -u -o $FICHERO $FICHERO
#Ahora vamos a purgar los paquetes dependientes y dejar solo los paquetes "primigenios"
if [ ! -f /usr/bin/apt-rdepends ]
then
echo "Instalando apt-rdepends"
apt-get install apt-rdepends
fi
cp /dev/null /tmp/musthave.new
cp /dev/null /tmp/musthave.deps
paquetes_explicitos=$(aptitude search '~i !~M' -F '%p' --disable-columns | sort -u)
for i in $paquetes_explicitos
do
echo -n "Paquete $i"
if grep $i $FICHERO > /dev/null
then
echo " ->instalado por musthave"
echo $i >> /tmp/musthave.new
else
if grep $i /etc/pkgsync/mayhave > /dev/null
then
echo " ->instalado por mayhave"
else
echo " ->instalado por musthave.d"
fi
fi
done
sort -u -o /tmp/musthave.new /tmp/musthave.new
num=1
total=$(wc -l /tmp/musthave.new)
for i in $(cat /tmp/musthave.new)
do
echo "Dependencias de $i: $num/$total"
((num++))
apt-rdepends $i |grep Depends: | awk ' { print $2 } ' | sed "/^${i}$/d" >> /tmp/musthave.deps
done
sort -u -o /tmp/musthave.deps /tmp/musthave.deps
comm -23 /tmp/musthave.new /tmp/musthave.deps > $FICHERO.final
echo "Proceso concluido, musthave en $FICHERO.final"
exit 0
Lanzamos el script y tras un intenso proceso que debemos dejar acabar con paciencia, en el fichero "musthave.$HOSTNAME.final" nos quedan los paquetes básicos para que funcione el pkgsync, que suele quedar en un 15% del musthave que obtenemos con el script original. Una vez generado este musthave en un equipo de pruebas lo podemos copiar a mano o por puppet al resto de equipos similares en su ubicación definitiva dentro de /etc/pkgsync/musthave o /etc/pkgsync/musthave.d/*.
Pedazo artículo el de Daniel Marín sobre el Apolo X, ahora que estamos en el 50 aniversario. Seguro que nos tiene preparada una maravilla sobre el Apolo XI en unas semanas.
A veces nos vendría bien conectarnos a la la sesión clonezilla que está ejecutando un compañero o nosotros mismos en otra ubicación, para así poder hacer la clonación desde nuestro puesto de trabajo o ver y depurar las causas de algún error.
Esto no es tan trivial como en un Linux corriente ya que clonezilla arranca como una distribución live con el servicio ssh apagado. Vamos a ver como habilitar el sshd y conectar a la red, permitiendo así la conexión remota desde otra ubicación.
Una vez arrancado clonezilla en el equipo, nos vamos a la shell (ya sea desde el menú o con CTRL-ALT-Fx) y activamos el servicio ssh con:
# sudo service ssh start
A continuación hay que conectar a la red el equipo, para ello nos aseguramos de que tiene un cable ethernet conectado y hacemos:
# sudo ocs-live-netcfg
Que mostrará el asistente de conexión a red. Lo habitual es elegir "dhcp" y apuntar la IP que se recibe.
Una vez hecho esto, el pc con el clonezilla queda a la espera, y desde la otra ubicación podemos conectarnos con:
# ssh user@ip.del.clonezilla
La contraseña por defecto es "live". Una vez conectados en remoto tenemos una shell desde donde realizar las tareas que deseemos sobre la máquina remota, incluyendo lanzar el asistente de clonezilla:
# sudo clonezilla
Si además estamos conectando a una ubicación remota donde hay un compañero, puedes sernos usar el comando "screen" para compartir la sesión y que ambos podamos ver a la vez lo que se hace en una pantalla común. Estos dos enlaces nos muestran como hacerlo:
Este es el tren de 60 satélites Starlink de Elon Musk surcando el cielo. Se pueden observar con unos prismáticos si estamos en una zona de baja contaminación lumínica.
Con este enlace podemos ver en tiempo real por donde va el tren de satélites y nos permite saber cuando pasará por nuestra vertical.
Seguimos con el Tvheadend. Después de instalarlo, configurarlo y conectarlo a varios streams de IPTV para jugar con ellos, en este post vamos a ver como configurarlo con una tarjeta de TV física.
1. Hardware.
Para ello usaremos una tarjeta TDT PCI. En su día ya estuvimos lidiando con otra parecida. Identifiquemos la tarjeta:
Y puesto que el driver está bien configurado, crea los dispositivos adecuados en /dev:
# ls -l /dev/dvb/adapter0/*
crw-rw----+ 1 root video 212, 4 may 15 16:49 /dev/dvb/adapter0/demux0
crw-rw----+ 1 root video 212, 5 may 15 16:49 /dev/dvb/adapter0/dvr0
crw-rw----+ 1 root video 212, 3 may 15 16:49 /dev/dvb/adapter0/frontend0
crw-rw----+ 1 root video 212, 7 may 15 16:49 /dev/dvb/adapter0/net0
2. Canales TDT.
Cada zona de España tiene sus propios canales TDT en función del repetidor. Por tanto, según sea nuestra ubicación geográfica debemos conocer que frecuencias se utilizan y qué canales hay disponibles dentro de cada frecuencia. Esto se puede consultar en la página http://www.tdt1.com, donde aparece la información tal que así:
Para no tener que meter las frecuencias a mano, todos los programas de manejo de la TDT (vlc, kaffeine, Tvheadend, ...) cuentan con algún script o fichero de configuración donde vienen las frecuencias de nuestra zona. En el caso de Tvheadend la ubicación de estos ficheros es:
# ls /usr/share/tvheadend/data/dvb-scan/dvb-t/es-*
/usr/share/tvheadend/data/dvb-scan/dvb-t/es-Alava
/usr/share/tvheadend/data/dvb-scan/dvb-t/es-Albacete
/usr/share/tvheadend/data/dvb-scan/dvb-t/es-Alfabia
/usr/share/tvheadend/data/dvb-scan/dvb-t/es-Alicante
...
Como a veces el gobierno reubica las frecuencias con el fin de hacer sitio para la telefonía móvil puede suceder que estos ficheros anteriores estén obsoletos. Afortunadamente hay gente que pone en github un repositorio con ficheros actualizados. Por tanto no está mal comparar el fichero correspondiente a nuestra zona con el del repositorio y actualizarlo si fuese necesario.
3. Configuración de Tvheadend.
Una vez pinchada la tarjeta y arrancado el PC, esta aparece en la configuración de Tvheadend al entrar por su interface web:
A partir de aquí, la secuencia de pasos es bastante parecida a lo hecho en el post anterior:
Creamos una red para la TDT: Configuration->DVB Inputs->Networks->Add Network->DVB-T Network (el nombre técnico real de la TDT es "DVB-T"):
En el formulario seleccionamos "Enabled", damos nombre a la red ("TDT"), y en "Pre-defined muxes" elegimos el fichero de configuración de frecuencias TDT correspondiente a nuestra zona (la que vimos en el apartado previo - en mi caso es "es-Carceres". No es un error: hace años alguien lo escribió mal y la errata se ha perpetuado):
Al dar a "Create" se crea la red y los muxes asociados a las frecuencias definidas en el fichero de configuración asociado.
Ahora hay que vincular la tarjeta de TV y la red, ya que si no Tvheadend no sabe dónde sintonizar las frecuencias definidas para los muxes recién creados. Para ello vamos a Configuration->DVB Inputs->TV Adapters y pinchamos sobre la tarjeta de TV. Aparecerá un formulario para la configuración de la misma. Allí nos aseguramos de que "Enabled" y "Over-the-air EPG" estén activados. En el desplegable "Networks" seleccionamos "TDT", que es la red creada en el paso anterior. Al dar al botón "Save" se guardan y aplican los cambios.
Muxes y servicios: ahora los muxes encuentran un "origen" de señal y empiezan a sintonizar los canales. En Configuration->DVB Inputs->Muxes nos aparece la lista de muxes, uno asociado a cada frecuencia (expresada en MHz):
Dentro de cada mux/frecuencia hay varios canales multiplexados. Esos canales deberían aparecer en la pestaña Configuration->DVB Inputs->Services:
Nota: en el caso de que no aparezcan los servicios de forma automática podemos volver a la pestaña Muxes y darle al reproductor de cada mux (botón de la columna más a la izquierda que muestra la etiqueta "Play this stream"), eso descarga un fichero con un stream que se abrirá en vlc y mostrará uno de los canales del mux. Al hacer esto se fuerza la detección de los canales y la creación de los servicios correspondientes.
Mapeo de los servicios en canales de Tvheadend: una vez tenemos cada uno de los canales de TDT sintonizados metido como servicio en Tvheadend es el momento de decidir que canal queremos que se converta en un canal de Tvheadend.
Recordemos que Tvheadend distingue entre servicio (un stream de vídeo entrante) y canal (canal de Tvheadend que aparecerá en el interface web, las aplicaciones cliente android y sobre el que podremos programar grabaciones). De esta manera podemos ignorar los canales entrantes que no nos interesen y configurar solo unos cuantos de ellos de cara al usuario final.
Esto lo hacemos en Configuration->DVB Inputs->Services->Map Selected, que permite mapear los servicios que queramos en canales:
Una vez mapeado, si nos vamos a Channel EPG->Channel podremos ver el canal recién creado:
Con esto dicho canal ya estará disponible en los clientes Tvheadend y sobre el podremos programar grabaciones y timeshifts. A partir de aquí sólo tendremos que repetir esto con todos los canales que nos interese tener.
4. Enlaces.
Para escribir este post he tenido que buscar la información en varias fuentes muy interesantes donde se hablan tanto de sintonización TDT como satélite, así que pongo los enlaces usados por si quisieramos ampliar:
La sonda lunar del Estado Nación Judío de Israel se hace un selfie un ratito antes de estrellarse violentamente contra la Luna, en lugar de aterrizar suavemente. Quizá lo confundió con la franja de Gaza.
Nos han llegado unos portátiles TechComputer TC11, unos clónicos que internamente se identifican (usando dmidecode podemos verlo) como P325J. Traen una imagen de Xubuntu 18 para miniportátiles casi totalmente configurada. Anotaré en esta entrada las modificaciones que vaya haciendo.
Lo primero es definir en /etc/escuela2.0 las variables que identifican al nuevo modelo de equipo, de cara a aplicar reglas puppet:
Para los portátiles tengo un módulo puppet "xubuntu18_portatil_ajustes", en la cual hay un case por $hardware:
...
case $hardware {
"TC11": {
file {"/etc/X11/xorg.conf.d":
owner => root , group => root , mode => 644 ,
ensure => directory,
}
file {"/etc/X11/xorg.conf.d/10-xorg-tc11.conf":
owner => root , group => root , mode => 644 ,
source => "puppet:///modules/xubuntu18_portatil_ajustes/10-xorg-tc11.conf",
}
#Cambia resolucion del grub para que en consola aparezca bien el contenido.
file { "/etc/default/grub":
source => "puppet:///modules/xubuntu18_portatil_ajustes/grub.default.TC11",
owner => root , group => root , mode => 644 ,
}
exec { "update-grub2":
subscribe => File ["/etc/default/grub"],
refreshonly => true
}
#Certificado ldap
file { "/etc/ldap/ssl/ldap-server-pubkey.pem":
owner => root , group => root , mode => 644 ,
source => "puppet:///modules/xubuntu18_portatil_ajustes/ldap-server-pubkey.pem",
}
}
...
Lo que hacemos es:
Añadir un /etc/X11/xorg.conf.d/10-xorg-tc11.conf con una configuración personalizada de Xorg. Por defecto estos portátiles vienen con una resolución altísima que deja la letra muy pequeña. El fichero 10-xorg-tc11.conf para una resolución de 1360x768 (se pueden probar otras resoluciones posibles usando el comando xrandr en un terminal) sería:
De igual manera, el grub aparece con una letra minúscula, para solucionar esto debemos meter un nuevo fichero /etc/default/grub y regenerarlo:
# If you change this file, run 'update-grub' afterwards to update
# /boot/grub/grub.cfg.
# For full documentation of the options in this file, see:
# info -f grub -n 'Simple configuration'
GRUB_DEFAULT=0
GRUB_HIDDEN_TIMEOUT=0
GRUB_HIDDEN_TIMEOUT_QUIET=true
GRUB_TIMEOUT=10
GRUB_TIMEOUT_STYLE=menu
GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
GRUB_CMDLINE_LINUX="ipv6.disable=1"
# Uncomment to enable BadRAM filtering, modify to suit your needs
# This works with Linux (no patch required) and with any kernel that obtains
# the memory map information from GRUB (GNU Mach, kernel of FreeBSD ...)
#GRUB_BADRAM="0x01234567,0xfefefefe,0x89abcdef,0xefefefef"
# Uncomment to disable graphical terminal (grub-pc only)
#GRUB_TERMINAL=console
# The resolution used on graphical terminal
# note that you can use only modes which your graphic card supports via VBE
# you can see them in real GRUB with the command `vbeinfo'
GRUB_GFXMODE=800x600
# Uncomment if you don't want GRUB to pass "root=UUID=xxx" parameter to Linux
#GRUB_DISABLE_LINUX_UUID=true
# Uncomment to disable generation of recovery mode menu entries
#GRUB_DISABLE_RECOVERY="true"
# Uncomment to get a beep at grub start
#GRUB_INIT_TUNE="480 440 1"
GRUB_DISABLE_OS_PROBER=true
Los portátiles no traen /etc/ldap/ssl/ldap-server-pubkey.pem, por lo que si usamos Secure LDAP la autenticación nos fallará. Metemos la clave (cogida de otra máquina que si la traiga) por si nos hace falta.
Seguiremos añadiendo cosas en este mismo post según vayan apareciendo problemas a resolver.
Addenda 17/mayo/2019:
Algunos portátiles una vez arrancados no cogen red y dan continuos errores en consola de RTC. Eso se debe a que tienen mal la fecha y debemos pulsar ESC o Supr en el inicio para entrar en la BIOS y meter la fecha correcta manualmente.
En algún portátil nos ha sucedido que en el arranque no carga el grub, sino que se muestra:
Que es una shell de EFI. Eso sucede porque en la BIOS no está configurado bien el orden de arranque de dispositivos, el cual debe ser:
Addenda 20/mayo/2019:
Cuando vamos a consola con CTRL-ALT-F1 todo se ve con letra minúscula, tal como se veía el GRUB inicialmente. La modificación hecha antes para arreglarlo en el GRUB no funciona una vez se ha cargado el sistema.
La solución es hacer un script que cargue un font que sea mas visible. El script se llamará /usr/bin/local/fontset:
Esto hace que el cambio de tamaño de font sea ya desde la petición de login...pero en la consola 2 y sucesivas (CTRL-ALT-F2, F3,..). En la primera consola (CTRL-ALT-F1) no comprendo por qué motivo no se cambia.
Si en lugar de estas 3 últimas líneas hacemos "setupcon" se consigue un resultado similar, pero en las pruebas me he encontrado con que no siempre funciona.
Addenda 22/mayo/2019:
Hemos tenido otro problema con el touchpad, que de manera aleatoria deja de funcionar cuando llevamos un rato trabajando, obligándonos a conectar un ratón USB. Se detecta como un dispositivo SYNA3602:00 0911:5288 Touchpad (podemos verlo con "cat /proc/bus/input/devices") y es manejado por el módulo i2c_hid. Si buscamos en Internet vemos que tiene un pequeño historial de problemas.
La solución propuesta por nuestros compañeros de servicios centrales es actualizar el kernel y sus módulos a la versión 5.0.0-15, lo cual podemos hacer con unas reglas puppet:
Y después de esto no vuelve a aparecer el problema del touchpad.
Addenda 23/mayo/2019:
Seguimos con cosas para corregir o mejorar que van descubriendo los compañeros.
En el escritorio de los portátiles parece el disco "sda2" accesible. Esta partición es donde se guarda clonezilla y lo mas adecuado es ocultarla con este fichero de configuración:
