En el colegio en el que trabajo tenemos una red de ordenadores relativamente grande (para ser un colegio, hay unos 1300 alumnos y 100 empleados): dos aulas de informática de unos 30 equipos cada una con su red propia, un ordenador en cada clase, varios en salas de profesores, secretaría y dirección, etc. En total, unos 165 equipos de usuario, junto con cinco servidores virtualizados y algún que otro dispositivo extra conectado a la red, como discos de backup (y no cuento con los ordenadores del programa Eskola 2.0, porque esos van a parte). Los ordenadores del colegio están actualmente dentro de un dominio Active Directory bajo Windows Server 2012, por lo que es requisito indispensable que todos los equipos estén dentro del dominio y se pueda utilizar la autenticación con los usuarios del dominio en todos ellos, incluyendo las máquinas Linux (cada empleado y alumno tiene su usuario y clave personal). Una de las tareas que más tiempo lleva todos los años es reinstalar equipos, y evidentemente, hacerlo a mano es perder el tiempo. No sólo el sistema operativo, el problema son todos los programas que se utilizan en las diferentes asignaturas. Para ello lo habitual es crear una imagen maestra y clonarla en los equipos en los que hay que reinstalar, configurando después cada instalación, e intentado que la configuración post-clonado sea lo más rápida y sencilla posible. Puestos en situación, el resumen de lo que voy a contar en este artículo es el siguiente:

1. Cómo realizar la imagen maestra con dos sistemas operativos (Windows 7 y Ubuntu Linux 13.04)
2. Cómo preparar la imagen para clonarla
3. Cómo clonar esa imagen
   1. en un ordenador individual
   2. con un servidor Clonezilla para realizar un clonado multicast en varios equipos al mismo tiempo
4. Cómo facilitar los pasos posteriores al clonado en Windows
5. Cómo facilitar los pasos posteriores al clonado en Ubuntu Linux 13.04, incluyendo la integración de los mismos en el directorio activo

En Windows no me voy a centrar demasiado, porque lo que más interesante me resulta de cara a educación es el uso de software libre, pero no tengo más remedio que incluir Windows en las imágenes. Aún así, como supongo que habrá más de un administrador de sistemas en mi situación, alguna cosilla también comentaré, por si sirve de ayuda.

Paso 1: la imagen maestra

En el caso de mi colegio el sistema operativo que más se utiliza es Windows 7 (aunque espero poder cambiarlo poco a poco), y algunos profesores, como yo, también utilizamos Linux en las clases con los alumnos. Por ello, el espacio necesario para partición de Windows será mayor que el necesario para la partición de Linux. Como el tamaño de la imagen no puede ser muy grande, y debería de poder adaptarse a los discos duros más pequeños del colegio (80 GB), la idea es:

• Instalar Linux al principio del disco, en una partición pequeña pero funcional.
• Instalar Windows detrás de dicha partición, para poder extender el tamaño tras el clonado con el espacio que quede en el disco.

Instalando Windows

Lo primero de todo instalaremos Windows 7. Este sistema operativo suele instalar una pequeña partición de unos 100 MB al comienzo del disco que utiliza para el arranque. En el proceso de particionado dejaremos esa partición, tras ella un espacio libre de unos 20 GB, y después, otros 25 GB en formato NTFS en los que instalaremos Windows. En mi caso creo un usuario «imagen» que será administrador local del equipo. Instalamos todos los programas necesarios, teniendo en cuenta que:

• No hay que activar Windows hasta después del clonado, ni meterlo hasta entonces en el directorio activo.
• Otros programas como Microsoft Office no pueden activarse tampoco hasta después del clonado.
• Ciertos programas, como el antivirus (en nuestro caso) tienen que instalarse tras el clonado.

Hasta ahora, eso era lo único que tenía en cuenta, y dejaba en el escritorio del usuario «imagen» algunas cosas que iba a necesitar tras el clonado. El problema era que, tras un tiempo, esas cosas quedaban obsoletas por diversos motivos, y eso hacía más lento todo el proceso post-clonado, al tener que actualizarlas. Para solucionar ese problema lo único que dejo ahora en el escritorio es una carpeta «postimage» con un pequeño script que se conecta a un servidor de ficheros y coge las últimas versiones de lo necesario tras la instalación. Este script se llama «getlatest.bat» y tiene tan sólo el siguiente contenido:

net use z: \\miservidordeficheros\postinstall /USER:miusuario
xcopy /E Z:\win32\* c:\Users\imagen\desktop\postimage\
net use z: /DELETE

Lo único que hacemos es conectarnos a una carpeta de red y copiar todo lo que hay en la carpeta actual (en mi caso tengo una carpeta win32 y otra linuxi386 con los ficheros de Windows y Linux en una carpeta compartida «postinstall» en un servidor cuyo nombre podemos resolver sin problemas por DNS). En general, si Windows 7 tiene acceso a internet durante la instalación, no suele tener problemas en instalar la mayor parte de los drivers que necesita. En c:\ crearemos una carpeta «drivers» en la que copiaremos los drivers de red de aquellos modelos de ordenadores que nos den problemas (tampoco pasa nada si copiamos ahí todos los drivers de red que tengamos). Una vez copiados, editaremos el registro de Windows con regedit y añadiremos «c:\drivers» en la entrada:

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\devicepath

Instalando Linux

Una vez instalado Windows con todo su software reiniciamos e instalamos la distribución de Linux que queramos. En mi caso, la última Ubuntu. Lo instalamos en el espacio que queda entre las dos particiones de Windows (arranque y sistema) dejando al propio instalador que particione. Normalmente creará una partición de 1 GB para Swap y el resto lo montará en /. Aquí también crearemos un usuario «imagen» que usaremos como administrador local (estará en el grupo de «sudoers»), e indicamos que queremos que instale GRUB 2 para gestionar la selección del sistema operativo al arrancar. Tras la instalación, instalamos todos los paquetes que nos interesen, y dejaremos en el escritorio del usuario «imagen» una carpeta «postimage» con un script (getlatest.sh):

#! /bin/bash
sudo mount.cifs //miservidordearcihvos/postinstall /mnt -o username=miusuario
sudo cp -r /mnt/linuxi386/* /home/imagen/Escritorio/postimage/
sudo umount /mnt

Vamos a asegurar que ese fichero sea ejecutable, ejecutando en un terminal, desde la carpeta «postimage»:

$ chmod 755 getlatest.sh

Y para terminar, ser buenos, y no volver loco a todo el mundo, vamos a poner como sistema operativo por defecto Windows en lugar de Ubuntu. Vamos a buscar el nombre exacto de la entrada de GRUB para el arranque en Windows, y la copiamos (comillas incluidas):

$ grep menuentry /boot/grub/grub.cfg

Editamos ‘/etc/default/grub’ y establecemos la opción ‘GRUB_DEFAULT’ con el texto que hemos copiado. Guardamos y actualizamos GRUB:

$ sudo update-grub

Aunque soy de KDE aquí he instalado Gnome como entorno de escritorio (luego contaré por qué), así que para terminar, vamos a arrancar, por defecto, con gnome clásico y sin efectos (así nos aseguramos de que no hay problemas en los ordenadores más antiguos), y de cara a que los alumnos puedan introducir su usuario, dejaremos que se pueda introducir éste a mano:

$ sudo apt-get install gnome-session-fallback
$ sudo /usr/lib/lightdm/lightdm-set-defaults -s gnome-fallback
$ sudo echo greeter-show-manual-login=true >> /etc/lightdm/lightdm.conf

De cara a poder añadir después el equipo a un dominio Active Directory, será necesario instalar los paquetes:

$ sudo apt-get install likewise-open samba cifs-utils smbclient

Una vez tenemos ambos sistemas operativos con todo el software instalado ya podemos crear la imagen…

Paso 2: preparando la imagen

Antes de hacer nada, vamos a hacer una imagen de la instalación tal y como está. Así, si vemos que nos falta algo, podemos restaurar en el ordenador maestro, cambiar lo que haga falta, y volver a empezar desde este punto. En mi caso tengo un disco en red con una carpeta compartida «images» en la que guardo las imágenes. Vamos a arrancar el ordenador utilizando la última versión de Clonezilla Live, y damos los siguientes pasos:

1. Si se quiere, por comodidad, idioma y teclado en español
2. Seleccionamos la opción «comenzar clonezilla» (clonezilla-start)
3. Vamos a grabar el disco en una imagen: device-image
4. Vamos a conectar a un disco samba (samba-server)
5. Configuramos la red por DHCP (si tenemos servidor DHCP, como es mi caso)
6. Indicamos cuál es el servidor de imágenes (p. ej. miservidordeimagenes, o la IP del mismo)
7. No utilizaremos dominio
8. Indicamos el usuario, carpeta y clave que vamos a utilizar
9. Seleccionamos el modo experto
10. Seleccionamos la opción «Savedisk»
11. Indicamos el nombre de la imagen
12. Seleccionamos la opción de eliminar los ficheros de paginación e hibernación de Windows (reduciremos un poco el espacio)
13. Importante: realizamos una comprobación interactiva del sistema de archivos (en caso contrario la partición Ext dará error y no se clonará)
14. Si tenemos tiempo, podemos dejar que el sistema compruebe que todo ha ido bien y la imagen se puede restaurar

En la partición Linux no hay nada especial que hacer, pero antes de clonar Windows hay que generalizar la imagen, de cara a borrar la información del equipo. Para ello ejecutamos:

c:\Windows\System32\sysprep\sysprep.exe

Seleccionamos:

Iniciar la configuración rápida (OOBE) del sistema
Generalizar
Apagar

Y esperamos a que el equipo se apague. Una vez apagado, volvemos a guardar una imagen siguiendo los mismos pasos que los que hemos indicado antes (importante: que no arranque Windows, porque tendremos que restaurar la imagen previa y volver a realizar el sysprep).

Paso 3a: clonar la imagen en un equipo individual

Esto es fácil. Vamos a coger la imagen que acabamos de preparar y a instalarla en un equipo individual. Para ello, arrancamos el equipo con Clonezilla Live:

1. Si se quiere, seleccionar idioma y configuración de teclado.
2. Seleccionar “Start_Clonezilla”
3. Seleccionar “device-image”
4. Seleccionar “samba_server”
5. En caso de que se pida, seleccionar la interfaz de red que va a utilizarse
6. Configuramos la red por DHCP (si es adecuado para nuestra red)
7. Seleccionamos el servidor de imágenes, bien por nombre (si resuelve por DNS), bien por IP
8. No se utilizará dominio
9. Indicamos el usuario, la carpeta de red a utilizar, y la clave
10. Se iniciará en modo experto
11. Opción “restoredisk”
12. Seleccionamos la última imagen adecuada disponible
13. Seleccionamos el disco en el que se quiere restaurar
14. Seleccionamos ignorar el chequeo del tamaño de disco (-icds) y quitamos la opción de redimensionar para adaptar al disco de destino (-r)
15. Usamos la tabla de particiones de la imagen
16. Confirmamos que queremos instalar la imagen en el equipo y esperamos
17. Una vez terminado, seleccionar qué queremos hacer al terminar (apagar, reiniciar o volver al Shell)

Paso 3b: clonar la imagen mediante multicast en varios equipos

Ésta es la parte más interesante. Vamos a preparar un servidor DRBL con clonezilla para poder clonar varios equipos a la vez, y después, lanzaremos el proceso de clonado.

Preparar el servidor DRBL

Vamos a necesitar un ordenador con, al menos, dos interfaces de red. Una de ellas se conectará a la red del colegio (eht0) y las demás se conectarán a switches que nos permitirán clonar varios equipos a la vez. En este ejemplo, mi caso, tengo una interfaz de red extra (eth1). El paso previo no lo voy a explicar con detalle, que es instalar en ese ordenador Ubuntu Server (yo he tenido que instalar la versión 12.04, porque los kernels versiones posteriores me han dado problemas con un modelo de ordenador que hay en mi colegio). Lo único reseñable, al finalizar, instalamos las funciones OpenSSH y Samba. Tras reiniciar, añadimos a /etc/apt/sources.list (si no lo están ya, y cambiando «precise» por la versión de Ubuntu que utilicemos):

deb http://archive.ubuntu.com/ubuntu precise main restricted universe multiverse
deb http://drbl.sourceforge.net/drbl-core drbl stable

Configuramos la segunda interfaz de red (en mi caso utilizo este rango de IPs, pero podría ser otro), añadiendo al fichero /etc/network/interfaces:

auto eth1
iface eth1 inet static
  address 192.168.100.1
  netmask 255.255.255.0

Reiniciamos la red, e instalamos actualizaciones y DRBL:

$ sudo service networking restart
$ wget -q http://drbl.org/GPG-KEY-DRBL -O- | sudo apt-key add -
$ sudo apt-get update
$ sudo apt-get dist-upgrade
$ sudo apt-get install drbl

Instalamos DRBL server:

$ sudo drblsrv -i

En mi caso, no instalamos las imágenes para instalación de sistemas operativos, no utilizaremos consola para clientes, instalamos los paquetes que faltan y seleccionamos el último kernel disponible (si hace falta, indicamos que se descargue por APT). Configuramos DRBL server:

$ sudo drblpush -i

1. Seleccionamos el dominio DNS, NIS/YIP y prefijo hostname por defecto
2. Usaremos eth0 para conexión a internet
3. No recopilamos MAC, a cada equipo se le ofrecerá una IP diferente cada vez
4. La primera IP la 100 y el número de clientes, 40. En mi caso, nunca voy a clonar más de 40 equipos a la vez.
5. Seleccionamos los modos DRBL completo y clonezilla completo
6. Seleccionamos /home/partimag para guardar las imágenes
7. Si hay swap en clientes lo usaremos, con el espacio por defecto
8. Por defecto, modo gráfico, login normal, sin contraseñas de root ni de pxelinux
9. Configuramos el prompt de inicio: 70 segundos, modo gráfico PXE Linux, sí a uso de vídeo, audio, etc., no a IP pública de los clientes ni a modo terminal
10. Sí utilizaremos el servidor como servidor NAT
11. Como no hemos creado clientes DRBL, conservamos la configuración de los ya existentes, pero si queremos reconfigurarlos, la podemos borrar
12. Reiniciamos el servidor

Para terminar, copiamos la imagen que teníamos en el disco de red en la carpeta /home/partimag:

$ sudo mount.cifs //servidordeimagenes/images /mnt/ -o user=usuarioimagenes
$ cp –r /mnt/carpetadelaimagen /home/partimag/

Y ya podemos apagar el servidor y llevarlo donde lo necesitemos.

Clonar varios equipos usando multicast

Arrancaremos el servidor DRBL conectado, con eth0, a la red del colegio, y con eth1 a un switch al que se conectan los equipos a clonar. Ejecutamos:

$ sudo dcs

Seleccionamos las siguientes opciones:

1. All – todos los clientes
2. Clonezilla start
3. Modo experto
4. Restore-disk
5. Seleccionamos la opción de ignorar tamaño de disco (-icds) y quitamos la opción de redimensionar el sistema de archivos (-r)
6. Utilizamos la tabla de particiones de la imagen
7. Saltamos la opción de proporcionar un servidor clonezilla al cliente
8. Al terminar, reiniciamos (o lo que consideremos oportuno)
9. Seleccionamos el archivo a restaurar y el disco (sda)
10. Seleccionamos que queremos restaurar a través de multicast
11. Seleccionamos clients-to-wait y el número de clientes que vamos a clonar (o la opción que consideremos más oportuna)

Una vez haya terminado la configuración de la sesión, arrancamos todos los clientes:

• Si puede arrancar por red utilizando la BIOS del propio equipo, utilizamos la red del propio equipo
• Si no puede arrancar por red, podemos utilizar Etherboot o la opción de arranque por iPXE de los CDs de Clonezilla Live.

Esperamos a que termine el clonado, y reiniciamos.

Paso 4: pasos posteriores al clonado con Windows

Tras reiniciar después del clonado arrancamos con Windows. Nos pedirá la configuración inicial (aceptar el acuerdo, nombre de usuario administrador local diferente al usuario «imagen» que ya tenemos creado, nombre del equipo, etc.). Aprovechamos para instalar el driver de la tarjeta de red, si por lo que sea no estaba instalado, las actualizaciones de Windows Update y ampliar el tamaño de la partición (no entro en detalles, porque entiendo que cualquier administrador de sistemas con los conocimientos mínimos sabe hacer esto). Nota: ya sé que es posible ahorrar algunos de estos pasos con un fichero de configuración personalizado en el sysprep, pero no he tenido tiempo de ponerme a ello.

Cerramos la sesión, iniciamos una nueva con el usuario «imagen» y nos vamos a la carpeta «postimage» del escritorio, para ejecutar el fichero «getlatest.bat» que descargará varios scripts que nos ayudarán.

Configurar la red, Powershell y activar Windows

El primer script que suelo ejecutar tiene el siguiente contenido:

netsh interface tcp set global autotuning=disabled
slmgr /ipk XXXXX-XXXXX-XXXXX-XXXXX-XXXXX
slmgr /ato
powershell Set-ExecutionPolicy Unrestricted

1. La primera parte cambia la configuración de red para solucionar un problema de nuestra red: por «imperativo externo» tenemos que utilizar una intranet Sharepoint de un determinado proveedor, y si no hacemos este ajuste en todos los equipos, las copias son extremadamente lentas.
2. Las siguientes dos líneas instalan la clave de activación de  Windows indicada (la que Microsoft nos proporciona cada 3 años al renovar la licencia) y dice al sistema que se active.
3. Finalmente, la última línea indica que queremos permitir la ejecución de scripts powershell.

Instalar los drivers que faltan

El siguiente script que ejecutaremos será un script Powershell que contiene las líneas:

# Obtener nombre de los drivers del equipo
$obj = Get-WMIObject -Class Win32_ComputerSystem
$name = ($obj | Select -Expand Name)

$client = New-Object System.Net.WebClient
$client.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)")
$response = $client.DownloadString("http://miservidor/getdrivers/$name")
if ($response -eq "*")
{
 Write-Host "No existen drivers para este equipo."
}
else
{
 $expr = "net use z: \\miservidor\software /USER:usuarioconacceso"
 Invoke-Expression $expr
 $expr = "mkdir drivers"
 Invoke-Expression $expr
 $expr = "xcopy /S Z:\drivers\postinstall\win32\$response\* drivers\"
 Invoke-Expression $expr
 $expr = "net use z: /DELETE"
 Invoke-Expression $expr
}
Read-Host "Pulsa Enter para continuar"

La URL «http://miservidor/getdrivers/$name» es un servicio web muy simple alojado en un servidor local que accede a una base de datos y dice si un determinado ordenador (identificado por su nombre) requiere drivers adicionales a los que Windows instala en la configuración inicial (o un «*» si no requiere drivers adicionales). En caso de requerirlos, nos conectamos a una carpeta de red con el identificador que nos ha devuelto el servicio web y copiamos el contenido en una carpeta local, y desde ahí, instalamos lo que sea necesario. Evidentemente, tenemos que tener una base de datos con los equipos que requieren drivers adicionales, y una carpeta compartida (miservidor\software) con carpetas para cada modelo, y los drivers ahí copiados.

Activar Office 2007

Para activar Office 2007, que es el que usamos, me ayudo de otro script Powershell que, para cada equipo, por nombre, me devuelve el serial de Office que tengo que utilizar (tengo packs que me proporcionan 20 licencias con un mismo serial, así que cada equipo tiene el suyo):

$obj = Get-WMIObject -Class Win32_ComputerSystem
$name = ($obj | Select -Expand Name)
$client = New-Object System.Net.WebClient
$client.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)")
$response = $client.DownloadString("http://miservidor/getofficeserial/$name")
Write $response
Read-Host "Pulsa Enter para continuar"

Al igual que antes, tenemos un servicio web (http://miservidor/getofficeserial/$name) que busca en una base de datos el serial que corresponde a ese ordenador, y nos lo devuelve, de forma que podemos copiar-pegar de manera sencilla y activar Office.

Añadir el equipo al dominio

Tras esto, sólo nos queda meter el equipo en el dominio, ejecutando el script Powershell (domain.ps1):

Add-Computer domain.fqdn.name -Cred domain\usuarioadministrador -PassThru

Pero como quiero poder ejecutarlo rápido desde el explorador, y necesito hacerlo como administrador, tengo un «.bat» al que le puedo hacer un «Ejecutar como administrador»:

PowerShell c:\users\imagen\Desktop\postimage\domain.ps1

Instalamos los programas que haga falta (antivirus, etc., cuyo fichero de instalación habremos descargado también a la carpeta «postimage» con el script «getlatest.bat»), y reiniciamos. Comprobamos que se ha añadido correctamente el equipo al dominio, y listos para seguir con la partición de Linux.

Paso 5: pasos posteriores al clonado con Linux

Los pasos para terminar el clonado con Linux son mucho más sencillos, porque generalmente no tendremos que perder el tiempo con licencias e historias similares.

Accedemos al sistema con el usuario «imagen» y ejecutamos el script «getlatest.sh» que tenemos en la carpeta «postimage» del escritorio. En este caso ejecutamos un sólo script que contiene:

#! /bin/bash
read -p "Se iniciará la configuración. Pulsa Intro para continuar. " tmpvar
read -p "Se copiarán los ficheros para las plantillas de los usuarios. Pulsa Intro para continuar. " tmpvar

# Montar las carpetas personales
sudo mkdir -p /opt/bin
sudo cp automount.sh /opt/bin
sudo chown -R root /opt/bin/automount.sh
sudo chgrp -R root /opt/bin/automount.sh
sudo chmod -R 755 /opt/bin/automount.sh

sudo mkdir -p /etc/skel/.config
sudo cp -r config/* /etc/skel/.config
sudo chown -R root /etc/skel/.config
sudo chgrp -R root /etc/skel/.config
sudo chmod -R 755 /etc/skel/.config
sudo chmod -R 644 /etc/skel/.config/autostart/mount.sh.desktop

# Actualizamos paquetes
read -p "Se actualizarán los paquetes de la instalación. Pulsa Intro para continuar. " tmpvar
sudo apt-get update
sudo apt-get dist-upgrade

# Limpiamos
sudo apt-get clean

read -p "Se añadirá el equipo al dominio. Pulsa Intro para continuar. " tmpvar
# Meter en dominio
sudo ./domain.sh

# Esperar
read -p "Pulsa Intro para continuar. " tmpvar

Con esto:

• Copiamos en /etc/skel una serie de ficheros que irán al perfil de todos los usuarios que accedan al sistema (luego los comentamos)
• Actualizamos todos los paquetes que se hayan podido renovar
• Ejecutamos el script que nos ayudará a introducir el equipo en dominio (desarrollado más adelante)

Para poder hacer esto, en el script «getlatest.sh» nos hemos descargado, además del propio script que tenemos justo encima:

• Los ficheros «automount.sh» y «mount.sh.desktop» que se copian en «/opt/bin» y «/etc/skel/.config/autostart» respectivamente (desarrollados abajo)
• El fichero «domain.sh» que permite añadir el equipo al dominio (desarrollado también abajo)

Acceso a las carpetas de usuario

Cada usuario tiene en la red una carpeta con su nombre. En Windows cada usuario se conecta automáticamente mediante una directiva en la política de grupo, pero en Linux no podemos usarla. Para ello, en la carpeta «autostart» de cada usuario se copiará un fichero con el contenido:

[Desktop Entry]
Type=Application
Exec=/opt/bin/automount.sh
Hidden=false
NoDisplay=false
X-GNOME-Autostart-enabled=true
Name[es_ES]=Mount shares
Name=Mount shares
Comment[es_ES]=
Comment=

Que ejecutará, cuando un usuario inicie sesión, el siguiente script:

#! /bin/bash

UNAME=`echo $USER | awk -F \\\\ '{ print $2 }'`
gvfs-mount smb://servidorficheros/$UNAME

rm /home/likewise-open/DOMAIN/$UNAME/Escritorio/$UNAME
ln -s /run/user/DOMAIN\\$UNAME/gvfs/smb-share\:server\=servidorficheros\,share\=$UNAME /home/likewise-open/DOMAIN/$UNAME/Escritorio/$UNAME

Este script hace uso de gvfs-mount de Gnome (por eso utilizo este entorno gráfico) para montar a nivel de usuario la carpeta personal de cada uno. Para que las aplicaciones no basadas en Gnome no tengan problemas para acceder a estas carpetas, creamos también un enlace a esta carpeta en el escritorio (borrándolo antes, por si existía).

Añadir el equipo al dominio

Para terminar, éste es el script que añade el equipo al dominio:

#! /bin/bash

read -p "Introduce el nombre del equipo: " newhostname
echo "El nombre introducido es $newhostname."
read -p "¿Estás seguro de querer utilizar ese nombre de equipo? (s/n): " sn
if [ $sn == "s" ]; then
 domainjoin-cli setname $newhostname
 domainjoin-cli join domain.fqdn.name usuarioadministrador
 lwconfig AssumeDefaultDomain true
 lwconfig UserDomainPrefix domain.fqdn.name
 sed -i 's/workgroup = WORKGROUP/workgroup = domain/g' /etc/samba/smb.conf
 sed -i 's/# security = user/security = ads/g' /etc/samba/smb.conf
 echo "REALM = domain.fqdn.name" >> /etc/samba/smb.conf
 echo "idmap backend = lwopen" >> /etc/samba/smb.conf
 echo "idmap uid = 50-9999999999" >> /etc/samba/smb.conf
 echo "idmap gid = 50-9999999999" >> /etc/samba/smb.conf
else
 echo "Vuelve a ejecutar el script introduciendo el nombre adecuado."
fi

Lo primero solicita el nombre que queremos dar al equipo, y si es correcto, lo cambia, y añade el ordenador al dominio.

Espero que os sirva de ayuda para algo  🙂