Manual de Rembo 2.0 - FORPAS Sevilla

Traducción al Español realizada por:
(en orden alfabético)
Sergio Baños Calvo ([email protected])
Gerardo Barea Pérez ([email protected])
Esteban Reche Barea ([email protected])
Macarena Titos González ([email protected])
José Antonio Toribio Díaz ([email protected])
Jorge Torres Chacón ([email protected])
Escuela Técnica Superior de Ingenieros en Informática
Universidad de Sevilla
Viernes, 15 de Febrero de 2002
ÍNDICE
ÍNDICE..........................................................................................................................2
MANUAL DE ADMINISTRACIÓN DEL SERVIDOR .....................................................9
CAPÍTULO 1: Instalación del servidor REMBO .....................................................................10
1.1.- Conceptos y requisitos ..............................................................................................10
1.1.1.- ¿Cómo funciona?..............................................................................................10
1.1.2.- Requisitos del Servidor .....................................................................................10
1.1.2.1.- Servidor DHCP .........................................................................................10
1.1.2.2.- Servidor REMBO ......................................................................................11
1.2.- Configuración del servidor DHCP .............................................................................11
1.2.1.- Servidor DHCP y REMBO en equipos diferentes.............................................11
1.2.2.- Servidor DHCP y REMBO en el mismo equipo ................................................11
1.2.2.1.- Añadiendo la opción 60 al servidor DHCP de WinNT 4 ...........................11
1.2.2.2.- Añadiendo la opción 60 al servidor DHCP de Win2000 ...........................12
1.2.2.3.- Añadiendo la opción 60 a un host con servidor ISC
DHCP ..........12
1.2.3.- Añadiendo REMBO a una infraestructura con Boot Discovery existente.........12
1.3.- Instalación de REMBO en Windows NT / 2000 ........................................................12
1.3.1.- Instalación .........................................................................................................13
1.3.2.- Configuración mínima .......................................................................................13
1.3.3.- Comprobando la configuración .........................................................................13
1.3.4.- Solución de problemas con el servicio NT........................................................13
1.4.- Instalación de REMBO en Unix.................................................................................14
1.4.1.- Instalación .........................................................................................................14
1.4.2.- Configuración mínima .......................................................................................14
1.4.3.- Instalando los ficheros del servidor...................................................................15
1.4.4.- Comprobando la configuración .........................................................................15
1.4.5.- Opciones de línea de comandos del servidor REMBO ....................................16
1.5.- Solución de problemas..............................................................................................16
1.5.1.- Rom de arranque PXE no detectada ................................................................16
1.5.1.1.- Descripción del problema .........................................................................16
1.5.1.2.- Resolución del problema ..........................................................................16
1.5.2.- En el arranque aparece DHCP... y un mensaje de error ..................................17
1.5.2.1.- Descripción del problema .........................................................................17
1.5.2.2.- Resolución del problema ..........................................................................17
1.5.3.- En el arranque aparece MTFTP... y un mensaje de error ................................18
1.5.3.1.- Descripción del problema .........................................................................18
1.5.3.2.- Resolución del problema ..........................................................................18
CAPÍTULO 2: Configuración del servidor REMBO ................................................................19
2.1.- Conceptos .................................................................................................................19
2.1.1.- Configuración basada en ficheros vs basada en registro.................................19
2.1.2.- Organización de parámetros.............................................................................20
2.1.3.- Configuración mínima .......................................................................................21
2.2.- Parámetros Globales ................................................................................................21
2.2.1.- Parámetros relativos al PXE .............................................................................21
2.2.2.- Parámetros específicos de REMBO .................................................................23
2.2.3.- Parámetros de configuración relacionados con la tolerancia a fallos...............23
2.3.- Dominios de autentificación ......................................................................................24
2.4.-Túneles TCP ..............................................................................................................25
2.5.- Grupos de servidor (Host groups).............................................................................26
2.5.1.- El grupo por defecto (default) ...........................................................................26
CAPÍTULO 3 : Herramientas administrativas del servidor REMBO .......................................28
3.1.- Netclnt .......................................................................................................................28
3.1.1.- NetClnt Interactivo............................................................................................28
3.1.1.1.- Primer paso: conexión con el servidor REMBO .......................................28
3.1.1.2.- Segundo paso: comprobación de la conexión..........................................28
3.1.1.3.- Tercer paso: experimentando con la conexión.........................................28
3.1.2.- Usando NetClnt en modo batch........................................................................29
3.1.3.- Comandos de NetClnt.......................................................................................29
3.2.- Consola del servidor .................................................................................................31
3.2.1.- Introducción.......................................................................................................31
3.2.2.- La interfaz .........................................................................................................31
3.2.3.- Añadir un servidor .............................................................................................31
3.2.3.1.- Servidor local ............................................................................................32
3.2.3.2.- Servidor remoto NT...................................................................................32
3.2.3.3.- Servidor remoto sin NT .............................................................................32
3.2.4.- Estado del servidor ...........................................................................................32
3.2.5.- Arrancando el servidor .....................................................................................32
3.2.6.- Parando el servidor ..........................................................................................33
3.2.7.- Recargando la configuración del servidor .......................................................33
3.2.8.- Modificación de los parámetros ........................................................................33
3.2.9.- Modificación de las variables ............................................................................33
3.2.10.- Ver los ficheros de log ...................................................................................34
3.2.11.- Acceso a los ficheros del servidor ..................................................................34
3.2.12.- Preguntas más frecuentes ..............................................................................34
CAPÍTULO 4 : Despliegue de REMBO en la empresa ..........................................................35
4.1.- Tolerancia a fallos .....................................................................................................35
4.1.1.- Tolerancia a fallos a nivel DHCP ......................................................................35
4.1.2.- Tolerancia a fallos a nivel REMBO ...................................................................36
4.2.- Front-end de la distribución.......................................................................................37
MANUAL DE ADMINISTRACIÓN DEL CLIENTE ......................................................39
CAPÍTULO 1 : Conceptos sobre REMBO ..............................................................................40
1.1.- ¿Qué es Rembo? ......................................................................................................40
1.2.- ¿ Cómo trabaja ?.......................................................................................................40
1.3.- Requisitos para el sistema cliente.............................................................................41
CAPÍTULO 2: Comenzando a usar REMBO ..........................................................................42
2.1.- Arrancando Rembo por primera vez .........................................................................42
2.1.1.- Cambiar la página de comienzo .......................................................................42
2.1.2.- Mostrar la consola Rembo ................................................................................42
2.2.- Experimentando con los scripts de Rembo ..............................................................43
2.2.1.- Arrancar el evaluador interactivo ......................................................................43
2.2.2.- Funciones básicas ............................................................................................43
2.2.3.- Funciones de disco ...........................................................................................43
CÁPITULO 3 : Trabajando con REMBO ................................................................................44
3.1.- Acceso a ficheros mediante REMBO........................................................................44
3.2.- Protocolos de red ......................................................................................................44
3.2.1.- Protocolo NETfs ................................................................................................45
3.2.2.- Protocolo MCAST .............................................................................................45
3.2.3.- Protocolo Metacast ...........................................................................................46
3.2.4.- Protocolo FAST.................................................................................................46
3.3.- Uso de variables en REMBO ....................................................................................47
3.3.1.- Introducción.......................................................................................................47
3.3.2.- Variables incorporadas (built-in) .......................................................................47
3.3.3.- Variables persistentes.......................................................................................47
3.4.- Creación de imágenes de disco y restauración ........................................................48
3.4.1.- Más sobre la clonación .....................................................................................48
3.4.1.1.- Clonación basada en sectores .................................................................48
3.4.1.2.- Clonación basada en estructura ...............................................................48
3.4.2.- Crear una imagen de disco...............................................................................49
3.4.3.- Cómo restaurar una imagen de disco...............................................................49
3.4.4.- Una restauración inteligente: Sincronización....................................................50
3.4.4.1.- Sincronización: cómo trabaja....................................................................51
3.4.4.2.- Aplicaciones del metodo de Sincronización .............................................51
3.4.4.3.- Sintáxis y uso del método de Sincronización ...........................................51
3.5.- Conceptos avanzados de clonación .........................................................................52
3.5.1.- Filtrando ficheros con Imágenes Virtuales........................................................52
3.5.2.- Imágenes incrementales ...................................................................................53
3.5.2.1- Imágenes incrementales básicas ..............................................................53
3.5.2.2.- Imágenes incrementales avanzadas ........................................................53
3.5.2.3.- Cómo crear una imagen incremental........................................................54
3.5.3.- Fusión de imágenes usando imágenes virtuales..............................................55
3.5.3.1.- ¿Cómo fusionar las imágenes? ................................................................55
3.5.4.- Conversión del tipo de partición........................................................................55
3.6.- Iniciando REMBO sin conexión a la red ...................................................................56
3.6.1.- Modo desconectado..........................................................................................56
3.6.1.1.- Configurando el modo desconectado .......................................................57
3.6.1.2.- ¿Cómo de seguro es el modo desconectado? .........................................57
3.6.1.3.- REMBO como gestor de arranque ...........................................................57
3.6.1.4.- Imágenes del modo desconectado...........................................................57
3.6.2.- Arrancar desde un CD de autoarranque...........................................................57
3.6.2.1 Creando un CD de autoarranque................................................................57
3.6.3 Arrancando REMBO desde un disquete .............................................................58
3.6.4 Activación PXE....................................................................................................58
3.7.- Uso de canales TCP para acceder a recursos remotos ...........................................59
3.7.1. Mandando correo electrónico con REMBO .......................................................59
3.7.2. Acceso a bases de datos con REMBO ..............................................................59
CAPÍTULO 4: INSTRUCCIONES ESPECÍFICAS PARA CADA
S.O. ......................................................................................................................................61
4.1.- Clonando MS-DOS....................................................................................................61
4.1.1.- Clonando un sistema MS-DOS.........................................................................61
4.1.2. Ajustando un sistema MS-DOS .........................................................................61
4.1.3. Instalando clientes Lan Manager para UNDI .....................................................62
4.2.- Clonando Windows 95/98 .........................................................................................63
4.2.1.- Creando una imagen base Windows 9x ...........................................................63
4.2.2.- Comprobando la imagen base del disco ..........................................................64
4.2.3.- Crear un script de restauración.........................................................................64
4.2.4.- Sincronizando en lugar de RestoreDiskImage .................................................65
4.2.5.- Personalizando .................................................................................................66
4.2.6. Imágenes incrementales básicas.......................................................................67
4.2.7. Imágenes incrementales avanzadas..................................................................68
4.2.7.1.- Restaurando una imagen incremental avanzada .....................................69
4.2.7.2.- Yendo mas allá .........................................................................................70
4.3.- Clonando Windows NT / 2000 ..................................................................................71
4.3.1.- Creando una imagen base Windows NT ..........................................................71
4.3.2.- Comprobando la imagen de disco base ...........................................................71
4.3.3.- Crear un script de restauración.........................................................................72
4.3.4.- Sincronización en lugar de restauración de una imagen..................................73
4.3.5.- Personalizando .................................................................................................74
4.3.6.- Imágenes incrementales básicas......................................................................74
4.3.7.- Imágenes incrementales avanzadas ................................................................75
4.3.7.1.- Restaurando una imagen incremental avanzada .....................................76
4.3.8.- Ficheros comprimidos .......................................................................................77
4.3.9.- Parcheando el SID de NT con REMBO ............................................................78
4.4.- Clonar Linux ..............................................................................................................79
4.4.1.- Creación de una imagen base Linux ................................................................79
4.4.2.- Arrancar un kernel de Linux ..............................................................................79
4.4.3.- Probar la imagen base del disco.......................................................................80
4.4.4.- Creación de un script de restauración ..............................................................80
4.4.5.- Imágenes incrementales de Linux ....................................................................81
4.4.6.- Personalizar scripts de arranque de Linux .......................................................82
MANUAL DE REFERENCIA DE REMBO-C...............................................................84
CAPÍTULO 1 : El lenguaje de scripts de Rembo-C................................................................85
1.1.- Utilidad ......................................................................................................................85
1.2.- Añadiendo scripts a las páginas Web.......................................................................85
1.3.- Creación de interfaces de usuario dinámicos ...........................................................85
1.4.- Creación de plug-ins precompilados ( librerías ) ......................................................86
CAPÍTULO 2 : El lenguaje......................................................................................................87
2.1.- Estructura de un programa Rembo-C .......................................................................87
2.2.- Declaraciones de variables y tipos............................................................................87
2.3.- Declaración de funciones ..........................................................................................88
2.4.- Expresiones...............................................................................................................88
2.5.- Sentencias de control................................................................................................89
2.6.- Hilos ( threads ) .........................................................................................................89
2.7.- Manejo de excepciones ............................................................................................89
2.8.- Programación orientada a objetos ............................................................................90
2.9.- Directivas pragma .....................................................................................................90
2.10.- Palabras reservadas ...............................................................................................90
2.11.- Resumen de diferencias entre C y Rembo-C .........................................................91
CAPÍTULO 3 : Bibliotecas de funciones.................................................................................92
3.1.- Cadenas ....................................................................................................................92
3.2.- Objetos binarios ........................................................................................................93
3.3.- Tablas y estructuras ..................................................................................................93
3.4.- Directorios .................................................................................................................93
3.5.- Ficheros.....................................................................................................................94
3.6.- Contenido de un fichero ............................................................................................94
3.7.- Interfaz de usuario.....................................................................................................95
3.8.- Primitivas relacionadas con la evaluación ................................................................95
3.9.- Variables persistentes ...............................................................................................96
3.10.- Primitivas relacionadas con la red ..........................................................................96
3.11.- Primitivas del sistema .............................................................................................97
ANEXO A : GUÍA RÁPIDA DE
INSTALACIÓN DE REMBO .................................99
GUÍA RÁPIDA DE INSTALACIÓN DE REMBO ...................................................................100
1.- Consideraciones previas ............................................................................................100
2.- Instalando REMBO.....................................................................................................100
3.- Instalando los Sistemas Operativos...........................................................................101
4.- Clonando Windows 2000 ...........................................................................................101
5.- Restaurando y arrancando Windows 2000 ................................................................101
6.- Clonando Windows 98 SE .........................................................................................102
7.- Restaurando y arrancando Windows 98 SE ..............................................................102
9.- Clonando Linux ..........................................................................................................103
10.- Restaurando y arrancando Linux .............................................................................103
ANEXO B : OTROS ASPECTOS DE REMBO .........................................................105
CAPÍTULO 1 : PERSONALIZANDO REMBO ......................................................................106
1.1.- Menú personalizado ................................................................................................106
1.2.- Modificar el menú raíz .............................................................................................106
1.3.- Rembo en castellano ..............................................................................................107
1.4.- Cambio pantalla de autentificación .........................................................................107
1.5.- Ejecución de scripts ................................................................................................108
1.6.- Instalación asistentes avanzados ...........................................................................108
CAPÍTULO 2 : ALGUNAS CUESTIONES DE SEGURIDAD ...............................................109
2.1.- Proceso de autentificación ......................................................................................109
2.2.- Asegurar arranque en Rembo.................................................................................109
2.3.- Bloqueo de periféricos ............................................................................................110
ANEXO C : MENÚ DE EJEMPLO ............................................................................111
MENÚ DE EJEMPLO ...........................................................................................................112
MANUAL DE ADMINISTRACIÓN DEL
SERVIDOR
Manual de Administración del Servidor
CAPÍTULO 1: Instalación del servidor REMBO
En este capítulo explicaremos cómo instalar el servidor Rembo. Siga cuidadosamente las
instrucciones de configuración pues cualquier parámetro incorrecto u omitido impedirá el
funcionamiento correcto del sistema.
1.1.- Conceptos y requisitos
El arranque remoto es el proceso de arrancar remotamente un ordenador usando recursos
remotos puestos a salvo en un servidor.
1.1.1.- ¿Cómo funciona?
La secuencia típica de arranque remoto es la siguiente:
1) Encendido: El ordenador remoto está encendido o esperando evento.
2) Descubrir dirección IP: Un servidor DHCP suministra direcciones IP a los clientes. El
servidor dará los parámetros de red necesarios para iniciar arranque remoto.
3) Descubrir servidor de arranque: El servidor de arranque remoto puede ser otra máquina
diferente al servidor DHCP. El servidor de arranque suministra un pequeño programa de
inicio de arranque en red al cliente usando un protocolo multicast (MTFTP).
4) Conexión NBP: REMBO utiliza una conexión segura mediante un servicio NBP. Permite
configurar parámetros de seguridad, el grupo de trabajo del cliente, bloquear puertos E/S...
5) Configuración pre-arranque (Pre-OS): REMBO ejecutará las acciones definidas en la
página de arranque, definidas como scripts en lenguaje Rembo-C.
6) Arranque del S.O.: Cuando se inicia el arranque del cliente REMBO se borra de
memoria. Esto asegura plena compatibilidad con el S.O. y evita los problemas tradicionales
del arranque remoto sin disco.
1.1.2.- Requisitos del Servidor
Serán necesarios un servidor DHCP y un servidor REMBO, que pueden ser la misma máquina
si se desea.
1.1.2.1.- Servidor DHCP
No hay requisitos especiales para el servidor DHCP. Si el servidor Rembo va a estar en el
mismo equipo que el servidor DHCP hay que definir la opción DHCP class identifier (opción
60).
Prácticas de Empresa 2001/02 1er Turno
Página 10
Manual de Administración del Servidor
1.1.2.2.- Servidor REMBO
El servidor REMBO puede funcionar sobre WinNT/2000, Linux(x86) y Solaris (Sparc). No hay
requisitos especiales. Sería recomendable usar un disco duro de gran tamaño si se prevee
usar muchas imágenes y lógicamente una CPU rápida para minimizar el tiempo de creación de
dichas imágenes (la mayoría del trabajo de compresión se realiza en el servidor).
1.2.- Configuración del servidor DHCP
Este documento asumirá que usted ya ha configurado su red para usar DHCP. Esta sección
explica como configurar su servidor DHCP para una de las tres situaciones siguientes:
•
•
•
El servidor DHCP y el servidor REMBO no están en la misma máquina.
El servidor DHCP y el servidor REMBO están en la misma máquina.
Usted ya tiene una infraestructura PXE 2.0 con "PXE Boot Server discovery" instalado
y quiere añadir REMBO a la lista de servidores disponibles.
1.2.1.- Servidor DHCP y REMBO en equipos diferentes
Las acciones que hay que realizar son :
•
•
Si las opciones DHCP 43 y 60 están puestas, elimínelas.
Si los servidores DHCP y REMBO están en diferentes máquinas, no hay nada que
cambiar en la configuración DHCP. El servidor REMBO detectará los paquetes DHCP
enviados por la bios de arranque remoto de los clientes y ofrecerá parámetro PXE sin
alterar la negociación estándar DHCP (este comportamiento es llamado DHCPProxy).
1.2.2.- Servidor DHCP y REMBO en el mismo equipo
Las acciones que hay que realizar son :
•
•
Si la opción 43 está puesta, elimínela;
Poner la opción 60 (Class identifier) a "PXEClient".
1.2.2.1.- Añadiendo la opción 60 al servidor DHCP de WinNT 4
Este proceso se realiza en dos pasos. Primero hay que crear una definición para la opción 60,
ya que esta no existe por defecto. Luego, habrá que añadir esta opción a un grupo de hosts o a
un solo host.
Paso 1. Añadir la opción 60 al conjunto de opciones soportadas.
Vaya a Opciones DHCP/Por defecto y haga click en Nueva. Añada una opción llamada
"Client Class", ponga tipo de dato "String" o "Cadena de texto" e identificador como 60.
Prácticas de Empresa 2001/02 1er Turno
Página 11
Manual de Administración del Servidor
Paso 2. Añadir la opción 60 al ámbito DHCP.
Seleccione el ámbito conteniendo los clientes PXE y vaya al menú Opciones
DHCP/ámbito. Añada la opción 60 y ponga el valor a "PXEClient".
1.2.2.2.- Añadiendo la opción 60 al servidor DHCP de Win2000
Por defecto la opción 60 no está activada bajo Win2000. Si el servidor REMBO está
ejecutándose en la misma máquina que el servidor DHCP, tendrá que añadir esta opción y
poner su valor a PXEClient para decirle a los clientes PXE donde encontrar el servidor
REMBO.
Para añadir esta opción siga los siguientes pasos:
1.
2.
3.
4.
5.
6.
Abra una ventana de símbolo del sistema.
Escriba netsh.
Escriba dhcp.
Escriba server \\nombre_servidor o server dirección_ip.
Debería ver un prompt indicando: dhcp server>
Escriba add optiondef 60 PXEClient STRING 0 comment=opción añadida para
soporte PXE.
7. Escriba set optionvalue 60 STRING PXEClient.
8. Para confirmar que todo se ha hecho correctamente, escriba show optionvalue all.
1.2.2.3.- Añadiendo la opción 60 a un host con servidor ISC
DHCP
Si está usando el servidor ISC DHCP 2.0, es posible añadir la opción 60 a un grupo de hosts
o a un único host añadiendo la sentencia option dhcp-class-identifier "PXEClient"; a una de las
secciones del fichero de configuración. Si está usando la opción 43 (vendor-encapsulatedoptions) para BPBatch, elimínela para servidores REMBO.
Las modificaciones a realizar para un servidor ISC DHCP 3.0 son las mismas, pero los
nombres varían:
•
•
Añada vendor-class-identifier "PXEClient"; para los hosts usando REMBO.
Elimine cualquier ocurrencia de option space PXE; si estaba usando BPBatch.
1.2.3.- Añadiendo REMBO a una infraestructura con Boot
Discovery existente
Si su red ya está configurada para PXE 2.0 Boot Server Discovery, todo lo que tiene que
hacer es añadir REMBO a su menú de arranque. El identificador del servidor de arranque
REMBO es 15. Si quiere usar resolución multicast, use la dirección IP multicast 232.1.0.1.
1.3.- Instalación de REMBO en Windows NT / 2000
REMBO viene preconfigurado con un conjunto mínimo de opciones (opciones obligatorias).
Podrá añadir nuevas opciones, nuevos grupos o hosts más tarde.
Prácticas de Empresa 2001/02 1er Turno
Página 12
Manual de Administración del Servidor
1.3.1.- Instalación
Para instalar el servidor REMBO, ejecute el programa que recibió cuando compró REMBO.
Este ejecutable instalará REMBO en un directorio de su elección, y realizará tareas básicas de
instalación.
Una vez la instalación haya acabado, usted debería tener los siguientes ficheros y directorios
en su directorio de instalación REMBO:
•
•
•
•
•
•
rembo.exe : este es el servidor. Como el servidor es un servicio NT, usted no
necesitará ejecutar este fichero directamente, a menos que esté intentando
ejecutar REMBO en modo depuración.
files/ : este es el directorio usado por REMBO para almacenar los archivos del
servidor. Usted no necesita modificar ningún fichero almacenado en este directorio.
misc/ : este directorio contiene archivos variados. En particular, contiene
netclnt.exe, una herramienta para modificar ficheros del servidor desde la línea de
comandos.
logs/ : este directorio es donde REMBO almacena sus archivos log. Usted puede
ver los ficheros en este directorio en cualquier momento para comprobar los
mensajes de error.
sconsole.exe : esta es la consola del servidor REMBO. Ver más abajo para más
detalles.
rconsole/ : este es la aplicación de consola remota, usada para interactuar
remotamente con el cliente REMBO.
1.3.2.- Configuración mínima
El proceso de instalación debería haber creado un nuevo grupo llamado Rembo Server en su
menú de inicio, con dos iconos:
•
•
La consola de servidor REMBO.
La aplicación de consola remota.
1.3.3.- Comprobando la configuración
Estando en la consola del servidor, haga click en su servidor local, entonces click en status.
La ventana derecha mostrará el estado de su servidor. Si el estado no es SERVER_RUNNING,
haga click con el botón derecho en el estado actual y seleccione start service. Esto debería
iniciar el servidor, y debería ver SERVER_RUNNING después de unos segundos. Si aún sigue
sin funcionar, vaya a la sección 1.3.4.
Una vez su servidor está funcionando, puede mostrar los ficheros del servidor y ver los logs
desde la consola de REMBO. Experimente su instalación ejecutando un cliente PXE. El
ordenador debería iniciar REMBO y mostrar un mensaje de bienvenida. Si no lo hace, mire los
logs en el servidor y asegúrese que su servidor DHCP está configurado para contestar a su
máquina PXE. Ver sección 1.5 si el cliente de arranque remoto no arranca.
1.3.4.- Solución de problemas con el servicio NT
Si su servidor no se inicia, o usted sospecha que algo va mal, tiene varias opciones para
obtener información de depuración desde el servidor:
Prácticas de Empresa 2001/02 1er Turno
Página 13
Manual de Administración del Servidor
•
•
•
Mire en el visor de eventos de NT. El servidor REMBO registra los mensajes fatales de
error en el manejador de eventos de NT.
Si el servicio no comienza, ejecute rembo.exe desde la línea de comandos con las
siguientes opciones: rembo -d -v 4. Esto ejecutará Rembo como una operación de
consola, redireccionando todos los mensajes a la consola. Puede incrementar el nivel
de depuración hasta 6.
Si el servicio funciona pero quiere información de depuración, ponga la opción
avanzada llamada GlobalDebugLevel a un valor entre 2 y 6 con la consola del
servidor.
1.4.- Instalación de REMBO en Unix
Esta sección describe como configurar su servidor REMBO bajo Unix (Linux o Solaris).
1.4.1.- Instalación
Elija el directorio donde quiere instalar el servidor REMBO (por ejemplo /usr/local/rembo).
Extraiga el contenido del paquete de distribución REMBO a este directorio. Entonces debería
ver:
• Un programa llamado rembo (el servidor);
• Un fichero de texto llamado rembo.conf (el fichero de configuración del servidor);
• Un fichero de texto llamado srvfiles.nc (el paquete de ficheros básico del servidor);
• Un subdirectorio llamado misc, con varios ficheros que puede necesitar mas tarde;
1.4.2.- Configuración mínima
Usando su editor de texto favorito, abra rembo.conf. Su contenido debería ser algo como
esto:
# Basic Rembo Server config file
#
# BaseDir <string>
# Specifies the home dir for the server. All paths can then be
# specified as relative to this base directory
# e.g. Basedir "c:/bootrom/rembo"
BaseDir "/usr/local/rembo"
# NetPassword <string>
# This password is used by the Rembo server to protect its files
# against an illegal use through the NETfs client (netclnt).
# This option is mandatory.
NetPassword "please set a password here"
#
# Default group. Hosts will take their parameters from this group.
# Unless you create other groups with hosts in it.
#
GROUP Default {
StartPage "net://global/rembo.shtml"
}
Muchos componentes adicionales pueden ser especificados en el fichero de configuración. Sin
embargo, todo lo que necesita configurar por ahora es la ruta donde instaló el servidor REMBO
(BaseDir), y un password para acceder a los ficheros del servidor con la utilidad netclnt (Net
Password).
Ya esta listo para iniciar el servidor por primera vez.
Prácticas de Empresa 2001/02 1er Turno
Página 14
Manual de Administración del Servidor
1.4.3.- Instalando los ficheros del servidor
El servidor REMBO necesita tener un conjunto mínimo de ficheros en su sistema de archivos
para que el cliente remoto arranque. Estos ficheros están contenidos en el fichero de texto
srvfiles.nc, y el método para instalar estos ficheros se describe en esta sección.
Primero debe arrancar el servidor escribiendo rembo -d -v 4 en la línea de comandos.
Durante la primera ejecución, el servidor necesitará un tiempo extra para generar una clave
criptográfica aleatoria.
Una vez el servidor este ejecutándose y esperando peticiones de conexión, edite el fichero
srvfiles.nc, y sustituya la línea open 127.0.0.1 install con open 127.0.0.1 xxxx donde xxxx es el
password que usted puso en el fichero rembo.conf (parámetro NetPassword).
Ahora puede ejecutar el comando misc/netclnt srvfiles.nc en el directorio de instalación del
servidor. Varios ficheros deberían ser transferidos al servidor, y NetClnt debería volver a la
línea de comandos después de que el último archivo haya sido enviado al servidor.
Su servidor está ahora listo para recibir peticiones desde los clientes de arranque remoto.
1.4.4.- Comprobando la configuración
Desde el directorio donde está el fichero de configuración, escriba rembo -d -v 2 para
arrancar el servidor REMBO. Esto le indicará al servidor que informe de los errores en la salida
estándar.
REMBO debe ejecutarse como root, ya que necesita acceso a puertos UDP privilegiados.
Además DHCP siempre debe ejecutarse antes que REMBO para que este último lo detecte.
Cada uno de los hilos del servidor debería mostrar un mensaje en la salida estándar, y
entonces esperar que un cliente se conecte. Asegúrese que no aparece ninguna advertencia ni
indicio de que un servicio haya sido desactivado. Algunos errores comunes son:
•
•
•
•
•
•
Arrancar el servidor sin privilegios de administrador (root), evitando la reserva de
algunos puertos;
Arrancar el servidor sin privilegios de escritura en el directorio base;
Tener otro servidor de arranque PXE ejecutándose en el mismo equipo, evitando que el
servidor REMBO reserve el puerto PXE BINL;
Tener un servidor TFTP configurado en el mismo equipo. Esto evita que REMBO entre
la secuencia de arranque a los clientes;
Ejecutar REMBO en un equipo sin capacidades multicast, como un equipo que solo
posee la interfaz loopback habilitada.
Ejecutar REMBO en un equipo con múltiples tarjetas de red sin especificar el
parámetro Interfaces.
Si obtiene alguna advertencia, detenga el servidor e intente arreglarlo. Una vez el servidor
esté ejecutándose correctamente, conecte un cliente. Después de unos segundos, REMBO
debería estar funcionando.
Prácticas de Empresa 2001/02 1er Turno
Página 15
Manual de Administración del Servidor
1.4.5.- Opciones de línea de comandos del servidor REMBO
El servidor REMBO puede ser ejecutado manualmente o a través de un script init.d. No debe
ser ejecutado por inetd.
rembo [-d] [-v nivel_de_log] [-c fichero_configuración]
•
•
•
-d : muestra información de depuración a la salida estándar, no se ejecuta como
demonio.
-v : ajusta el nivel de detalle de la información mostrada (por defecto: 2).
-c : especifica el fichero de configuración (por defecto: rembo.conf).
Los niveles de detalles de la información mostrada están definidos como :
•
•
•
•
•
•
•
0 : sin salida.
1 : sólo mensajes de error.
2 : sólo mensajes de error y advertencias.
3 : mensajes de error, advertencias y mensajes de información.
4 : igual que 3, pero también mensajes de notificación.
5 : igual que 4, con salida de depuración.
6 : igual que 5, con trace de red.
1.5.- Solución de problemas
1.5.1.- Rom de arranque PXE no detectada
1.5.1.1.- Descripción del problema
Durante el proceso de arranque, no hay mensaje sobre la rom de arranque PXE, y el
ordenador arranca como es usual (desde floppy, disco duro o CD-ROM).
1.5.1.2.- Resolución del problema
Primero compruebe que su tarjeta de red está correctamente instalada, y que el chip de
arranque remoto está instalado en dicha tarjeta. Para comprobar que la tarjeta de red funciona,
ejecute Windows o Linux, y configure el sistema operativo para que sea capaz de hacer ping a
otras máquinas (o para ser capaz de ver a otros equipos en el entorno de red).
En ciertas tarjetas de red, el chip de arranque remoto PXE puede no estar activado por
defecto. Lea la documentación del producto para encontrar la combinación de teclas que debe
presionar para entrar en el menú de configuración PXE en el momento del arranque. Algunas
tarjetas pueden no tener dicho menú de configuración.
Entonces, entre en la configuración de la BIOS durante el arranque, y configure el proceso de
arranque para que la tarjeta de red sea la primera entrada en la lista de arranque. En algunas
BIOS, hay una opción para activar el arranque en red. En otras BIOS, debe poner
manualmente la opción de red como el primer dispositivos de arranque.
Prácticas de Empresa 2001/02 1er Turno
Página 16
Manual de Administración del Servidor
Si todos estos pasos fallan, intente obtener una actualización para la memoria flash de su
tarjeta de red, y actualice la rom de la tarjeta de red con dicha actualización. Si el proceso de
flash falla, posiblemente no exista chip de arranque remoto en la tarjeta de red.
Si aún así no ve los mensajes PXE, pregunte al fabricante de su tarjeta de red.
1.5.2.- En el arranque aparece DHCP... y un mensaje de error
1.5.2.1.- Descripción del problema
El chip de arranque remoto no recibe suficiente información para continuar. El servidor DHCP
o el servidor REMBO no están correctamente configurados.
1.5.2.2.- Resolución del problema
Primero compruebe que su servidor DHCP esta correctamente configurado como se explica
en la sección 1.2. En particular, compruebe que la opción 60 esta puesta a PXEClient, sólo si
está ejecutando el servidor DHCP y el servidor PXE en la misma maquina.
Si el servidor DHCP y el servidor REMBO están en la misma máquina, intente detener ambos
servidores, y reiniciarlos en el siguiente orden: el servidor DHCP primero, y luego el servidor
REMBO.
Compruebe su configuración DHCP: ejecute Windows o Linux en su cliente de arranque
remoto, y configure la red para usar configuración dinámica en lugar de dirección IP fija. Si
funciona (ejecute winipcfg o ipconfig en Windows, o ifconfig en Linux), entonces el servidor
DHCP esta configurado correctamente para esa máquina. Si no funciona, compruebe la
configuración del servidor DCHP.
Si su servidor está correctamente configurado (incluyendo opción 60), y el cliente aún muestra
DHCP... seguido por un error, compruebe la configuración del servidor REMBO. Detenga el
servidor REMBO, ejecute rembo.exe -d -v 6, y arranque el cliente de arranque remoto. Cuando
comience, el servidor debería mostrar una línea diciendo si está actuando como DHCP Proxy o
como BINL Proxy. Si el servidor DHCP y el servidor REMBO están en la misma máquina, el
servidor REMBO debe actuar como BINL Proxy. Si están en diferentes máquinas, el servidor
debe actuar como DHCP Proxy. Si el servidor muestra un mensaje diciendo que esta actuando
como BINL Proxy, pero los dos servidores no están en la misma máquina, significa que hay un
servidor DHCP habilitado en la máquina donde está instalado el servidor REMBO.
Cuando un cliente arranca, y el DHCP está correctamente configurado, el servidor REMBO
(en modo depuración) debe mostrar Valid discovery from ... seguido por Client ... found in group
... . Si el servidor muestra la primera línea, pero muestra Client ... not found in any group en la
segunda línea, significa que el fichero de configuración no contiene un grupo de trabajo por
defecto, y el cliente de arranque remoto no está declarado en ningún grupo (el cliente debe
estar declarado con su dirección hardware, no con su dirección IP).
Si el servidor no muestra el mensaje Valid discovery request from ..., significa que la opción
60 del servidor DHCP no está correctamente puesta (ver sección 1.2), o el servidor REMBO y
el servidor DHCP no están en la misma subred. Si tienes instalado REMBO en un host con
varias tarjetas de red, use la opción Interfaces para especificar que tarjeta usar.
Prácticas de Empresa 2001/02 1er Turno
Página 17
Manual de Administración del Servidor
1.5.3.- En el arranque aparece MTFTP... y un mensaje de error
1.5.3.1.- Descripción del problema
El chip de arranque remoto es incapaz de recibir la secuencia de arranque desde el servidor.
1.5.3.2.- Resolución del problema
Si el intervalo de tiempo entre el mensaje MTFTP... y el mensaje de error es muy corto, y el
mensaje dice que un fichero no ha sido encontrado, significa que el ordenador donde tiene
instalado REMBO ya ejecuta un servidor TFTP (y este servidor TFTP contesta a las peticiones
del servidor REMBO). Si está usando Windows NT/2000 en el servidor, verifique la lista de
servicios, y desactive los servicios relacionados con TFTP o protocolos de arranque (Intel LCM,
Microsoft PXE, ...). Si está usando Linux/Solaris, compruebe que no hay procesos tftp
ejecutándose, y que la línea con tftp in el fichero /etc/inetd.conf está comentada.
Si el intervalo de tiempo es largo, significa que los datagramas multicast TFTP enviados por el
servidor REMBO no están siendo recibidos por el cliente de arranque remoto. Compruebe que
multicast está activado en el kernel si está usando Linux/Solaris en el lado del servidor. Si está
usando REMBO en un servidor con varias tarjetas de red use el parámetro Interfaces para
especificar qué tarjeta de red desea usar para los paquetes multicast.
Prácticas de Empresa 2001/02 1er Turno
Página 18
Manual de Administración del Servidor
CAPÍTULO 2: Configuración del servidor REMBO
Este capítulo contiene una descripción exhaustiva sobre los parámetros de configuración del
servidor.
2.1.- Conceptos
2.1.1.- Configuración basada en ficheros vs basada en registro
En un servidor Windows 2000/NT todos los parámetros se almacenan en el registro de
sistema. En los servidores Unix se almacenará en ficheros. El siguiente ejemplo muestra un
archivo de configuración. Están incluidos todos los parámetros, pero aquellos que no
corresponden a la configuración mínima han sido comentados:
----------------- rembo.conf -----------------# Ejemplo de configuración de servidor Rembo
################################
### PARÁMETROS GLOBALES
###
################################
#
- PARÁMETROS COMUNES -
#
Basedir "/usr/local/rembo"
NetPassword "Por favor, introduzca aquí una clave"
# Nota: la opción Interfaces es parte de la configuración mínima si usa
# múltiples servidores o conexiones a servidores.
Interfaces 192.168.1.4
#
#
#
#
#
- PARÁMETROS PXE - #
DisableDHCPProxy
BootNoMulticastDiscovery
BootDiscoveryAddress 232.2.0.1
BootDiscoveryPort 4011
#
#
#
#
MTFTPPort 4015
MTFTPClients 231.1.0.1:8500
MTFTPStartDelay 2
MTFTPMCastTTL 1
#
- PARÁMETROS DE REMBO -
#
# NBPServerPort 4012
#
#
#
#
#
#
#
#
DataDir "files"
FileServerPort 4013
FileMCastAddress 239.2.0.1:10000
FileMCastTTL 1
MCASTEncrypt
FASTEncrypt
FASTPort 4025
- PARÁMETROS DE TOLERANCIA A FALLOS -
#
# BootReplyDelay 1
# Backup 192.168.1.8
#####################################
### AUTENTIFICACIÓN DE DOMINIOS ###
#####################################
Prácticas de Empresa 2001/02 1er Turno
Página 19
Manual de Administración del Servidor
#
- DOMINIO LOCAL -
#
# AuthLocalDomain lcltest {
# Usergroup "rembo"
# }
#
#
#
#
#
#
#
#
#
#
- DOMINIO NT -
#
AuthNTDomain ntatest {
AuthServerName "company-pdc"
Usergroup "rembo"
}
- DOMINIO RADIUS -
#
AuthRadiusDomain radtest {
AuthServerAddress 192.168.1.15
RadiusSecret "testing123"
}
###############################
### GRUPOS DE SERVIDORES
###
###############################
#
- Grupo por defecto -
#
Group Default {
Options admin
}
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
- Grupo de ejemplo -
#
Group TestGroup {
FileServer 192.168.10.10
Options admin
Lockout mouse
AuthDomain "lcltest"
StartPage "net://global/mypage.html"
RemoteConsole 192.168.1.10
Host
192.168.1.118
Host
192.168.1.119 {
StartPage "net://global/special.html"
}
Host
00:10:4b:12:12:12
HostRange 192.168.2.1 -> 192.168.2.254
HostRange 192.168.3.1 -> 192.168.3.254 {
AuthDomain "nttest"
}
}
2.1.2.- Organización de parámetros
Los parámetros se organizan en 3 grupos: Parámetros globales, dominios de autentificación y
grupos de servidores.
•
Parámetros globales : opciones de configuración del servidor a bajo nivel. Se dividen
en 4 partes: comunes a todos los servicios, relacionados con el arranque PXE,
servicios específicos de Rembo y tolerancia a fallos.
•
Dominios de autentificación : grupos de trabajo.
•
Grupos de servidores : Para agrupar servidores con la misma información de
configuración.
Nota: cualquier modificación de los parámetros globales requiere reiniciar la máquina.
Prácticas de Empresa 2001/02 1er Turno
Página 20
Manual de Administración del Servidor
2.1.3.- Configuración mínima
Al instalar REMBO por primera vez viene con una serie de parámetros mínimos por defecto,
necesarios para arrancar el servidor REMBO. Si editas el fichero de configuración rembo.conf
(en un servidor basado en ficheros) deberás establecer 2 variables:
•
•
BaseDir: el directorio donde REMBO se ha instalado.
NetPassword: clave elegida para proteger los ficheros contra accesos ilegítimos.
2.2.- Parámetros Globales
Como se ha indicado previamente, el servidor REMBO necesita los parámetros globales para
funcionar. Normalmente no es necesario modificar ningún parámetro global salvo Basedir,
NetPassword o Interfaces.
En la configuración basada en registros (léase Windows 2000/NT) los parámetros globales
necesarios se introducen durante la instalación. Si trabajas con el sistema basado en ficheros
deberás editarlos a mano. El formato de estos es:
•
Basedir "cadena" : Especifica el directorio base para el servidor. Todos los paths
incluidos en la configuración son relativos a este directorio. Este parámetro es
obligatorio, y no tiene valor por defecto.
•
NetPassword "cadena" : REMBO utiliza este password para proteger sus archivos de
acceso remoto no autorizado. Si usas netclnt, tendrás que añadir este password como
opción del comando open para poder acceder a los archivos del servidor remotamente.
Si usas la consola del servidor, tendrás que introducir el password solo si añades un
servidor en el modo de servidor remoto. Si el servidor es local, o un servidor Windows
NT remoto, la consola toma este password del registro (leer el manual para más
información).
•
MaxLogSize número : Este parámetro se usa para limitar el tamaño de los ficheros de
log que genera el servidor REMBO. El tamaño máximo se especifica en bytes, y se
aplica a todos los ficheros de log generados por el servidor (file,nbp y boot). Si no se
especifica, o el límite es 0, no hay límite de tamaño (leer el manual para más
información).
•
Interfaces "cadena" : Este parámetro especifica la lista de interfaces de red usados por
el servidor cuando recibe y envía paquetes a los clientes REMBO. Si no se indica, el
servidor usará el interfaz de red correspondiente al hostname del servidor (leer el
manual para más información).
El resto de parámetro globales se usan para definir parámetros avanzados, relacionados con
el comportamiento PXE del servidor REMBO, y parámetros específicos de REMBO.
2.2.1.- Parámetros relativos al PXE
El servidor REMBO implementa todos los servicios requeridos para un arranque PXE,
permitiendo deshabilitar los servicios no requeridos en tu entorno o cambiarlos para
acomodarlos a una infraestructura PXE ya existente. Existen 3 formas diferentes de detectar al
servidor PXE:
Prácticas de Empresa 2001/02 1er Turno
Página 21
Manual de Administración del Servidor
•
La opción 60 del DHCP está puesta a PXEClient.
Si el paquete respuesta que llega al cliente incluye dicha opción iniciada a ese mismo
valor (PXEClient), el cliente sabrá que el servidor PXE es el mismo que el DHCP. La
negociación continuará enviando un paquete por el puerto UDP 4011 del servidor. Si
has
elegido
este
modo
puedes
deshabilitar
DisableDHCPProxy
y
BootNoMulticastDiscovery.
•
El servidor PXE envía una respuesta PXE para descubrir el DHCP (DHCP Proxy).K
Si el servidor DHCP y el PXE están en diferentes máquinas, el servidor PXE puede ser
configurado para responder a una petición DHCP (DHCPDISCOVER). De este modo el
cliente recibirá 2 paquetes de respuesta: el primero enviado por el servidor DHCP
(DHCPOFFER) que contiene su dirección IP y los parámetros de red asociados al
arranque remoto, y el segundo enviado por el servidor PXE conteniendo las opciones
específicas PXE.
•
La respuesta DHCP informa al cliente que ejecute un descubrimiento multicast
Si no se puede usar ninguno de los métodos anteriores el servidor DHCP se puede
configurar para incluir los parámetros PXE para un descubrimiento multicast. Estos
parámetros dirán al cliente como ejecutar un descubrimiento multicast PXE (que
dirección usar y qué servidor buscar). La especificación PXE define qué parámetros
DHCP deben cambiarse para el descubrimiento multicast. La identificación de arranque
(Boot ID) para servidores REMBO es 15. En este modo, BootNoMulticastDiscovery no
debe ser iniciada y BootDiscoveryAddress debe iniciarse a la dirección multicast de tu
infraestructura de descubrimiento. Si quieres puedes deshabilitar el DHCPProxy con
DisableDHCPProxy.
Nota: Si tienes múltiples servidores REMBO en una la misma subred puedes implementar
balance de carga y tolerancia a fallos habilitando DHCPProxy en todos los servidores y
definiendo los clientes en todos ellos.
Guía de referencia rápida de parámetros PXE
•
•
•
•
DisableDHCPProxy : Deshabilita el servicio DHCPProxy. El servidor no enviará
respuestas DHCP extendidas (respuestas PXE) a los paquetes DHCP enviados por el
cliente (leer el manual para más información).
BootNoMulticastDiscovery : Se deshabilitará el descubrimiento PXE multicast. El
servidor no escuchará los paquetes PXE multicast de descubrimiento (leer el manual
para más información).
BootDiscoveryAddress dirección_ip : Dirección IP multicast que los servidores
escuchan cuando se esperan paquetes PXE de descubrimiento multicast (leer el
manual para más información).
BootDiscoveryPort puerto : El puerto que el servidor escucha para paquetes de
descubrimiento multicast y respuestas BINL (leer el manual para más información).
Otra parte importante del soporte PXE implementado en REMBO es el servicio MTFTP
(Multicast Trivial File Transfer Protocol). Se utiliza para cargar la parte inicial de REMBO en el
cliente. Una vez hecho esto, los protocolos propietarios son usados para proporcionar un
servicio más eficiente y seguro. El servicio MTFTP implementado en REMBO es una
implementación parcial de la especificación del protocolo, orientada al cliente. Los siguientes
parámetros permiten configurarlo, aunque sus valores por defecto funcionan habitualmente:
Prácticas de Empresa 2001/02 1er Turno
Página 22
Manual de Administración del Servidor
•
•
•
•
MTFTPPort puerto : Puerto usado por el servidor para escuchar peticiones MTFTP
(leer el manual para más información).
MTFTPClients puerto [:puerto-cliente] : Dirección IP destino y puerto usado por el
servidor para mandar datagramas MTFTP multicast a los clientes(leer el manual para
más información).
MTFTPStartDelay segundos : Retraso en el cliente antes de mandar la primera
petición MTFTP (leer el manual para más información).
MTFTPMCastTTL ttl : Define el Time-To-Live (TTL) o etiqueta temporal asociado a los
paquetes multicast (leer el manual para más información).
2.2.2.- Parámetros específicos de REMBO
Se utilizan para modificar el comportamiento de los servicios de ficheros y NBP en el servidor.
Probablemente no deberás modificarlos a menos que requieras cambiar los puertos porque ya
estaban ocupados por otros servicios.
Guía de referencia rápida de parámetros específicos de Rembo
•
•
•
•
•
•
•
•
NBPServerPort puerto : puerto UDP por el que se reciben las peticiones NBP de los
clientes. Se recomienda no modificar su valor (leer el manual para más información).
DataDir "ruta" : Directorio que contiene los ficheros internos del servidor (leer el
manual para más información).
FileServerPort puerto : Puerto UDP usado por el servidor para recibir peticiones
NETfs, MCAST y FAST (leer el manual para más información).
FileMCASTAddress dirección_ip:puerto
(y FileMCASTAddrCount) : Dirección
IP:puerto destino usados por el servidor REMBO cuando se envían datagramas
multicast para el protocolo MCAST (leer el manual para más información).
FileMCASTTTL ttl : Time-To-Live asignado a los datagramas multicast enviados por el
servidor a los clientes cuando se usa el protocolo MCAST. (leer el manual para más
información).
FileMCASTEncrypt : Encripta todos los datagramas enviados con el protocolo MCAST
(leer el manual para más información).
FastEncrypt : Encripta todos los datagramas enviados con el protocolo FAST (leer el
manual para más información).
FastPort puerto : Puerto usado por el servidor cuando los clientes usan el protocolo
FAST para enviar paquetes al servidor (leer el manual para más información).
2.2.3.- Parámetros de configuración relacionados con la
tolerancia a fallos
Un sistema de tolerancia a fallos es aquel capaz de continuar incluso cuando falla uno de sus
componentes. En el caso de los servidores REMBO puedes configurar un servidor para que no
responda a peticiones del cliente a menos que el servidor primario haya caído. Esto asegura
alta fiabilidad cuando el servidor primario falla o se están llevando a cabo tareas de
mantenimiento que requieren el apagado del equipo.
Guía de referencia rápida de parámetros de tolerancia a fallos
•
•
Backup dirección_ip : Dirección IP de un servidor REMBO backup (leer el manual para
más información).
BootReplyDelay segundos : Segundos que esperará el servidor antes de mandar
paquetes de respuesta a un paquete de descubrimiento multicast, a uno BINL o a uno
de descubrimiento DHCP (leer el manual para más información).
Prácticas de Empresa 2001/02 1er Turno
Página 23
Manual de Administración del Servidor
2.3.- Dominios de autentificación
Un dominio de autentificación es un grupo de parámetros relativos a la autentificación de
usuarios por REMBO. El término dominio no tiene nada que ver con los dominios de Windows
NT o los dominios NIS+. Los parámetros contenidos en un dominio de autentificación definen
cómo la información del usuario y clave introducida en el equipo de un cliente REMBO es
chequeada por el servidor. Por ejemplo, podría chequearse en una base de datos local al
servidor o a través de un dispositivo de autentificación remota (con Radius). Asimismo REMBO
puede restringir la búsqueda a grupos simples de usuarios en entornos NT o Unix para mayor
flexibilidad.
El servidor REMBO soporta varios protocolos de autentificación dependiendo de la plataforma
del servidor:
•
•
•
En Windows NT un usuario puede identificarse con la base de datos local o con una
base de datos remota (también ubicada en un servidor NT).
En Unix el usuario se identifica con las funciones de la base de usuarios estándar, que
puede configurarse para usar ficheros locales, NIS o NIS+.
En ambas plataformas, el servidor REMBO puede usar la autentificación estándar de
Radius con un dispositivo que soporte el protocolo Radius, o con una puerta de enlace
(gateway) Radius para Netware (NDS) por ejemplo.
Nota: bajo Windows NT la autentificación solo puede hacerse si el usuario que ejecuta
REMBO tiene el permiso Actuar como parte del Sistema Operativo. Por defecto, la cuenta de
usuario utilizada para los servicios lo tiene (cuenta System).
Si estás usando una configuración basada en ficheros (p.e. Unix), debe añadir los dominios
de autentificación al fichero de configuración. Cada dominio comienza con AuthLocalDomain,
AuthNTDomain (en Windows NT solamente), o AuthRadiusDomain, seguidos por el nombre
que quieres atribuir al dominio. El nombre del dominio puede ser usado en grupos y así unir
grupos de autentificación y grupos de usuarios. Un ejemplo con las 3 formas de autentificación:
AuthLocalDomain lcltest {
UserGroup "rembo"
}
AuthNTDomain ntatest {
AuthServerName "company-pdc"
Usergroup "rembo"
}
AuthRadiusDomain radtest {
AuthServerAddress 192.168.1.15
RadiusSecret "testing123"
}
Si utiliza una configuración basada en registros puede añadir un nuevo dominio de
autentificación con la consola del servidor pinchando en la subtecla Parámetros y eligiendo
Añadir Dominio de Autentificación desde el menú Añadir / Eliminar. Te aparecerá un formulario
para definir los parámetros del dominio.
Guía de referencia rápida para dominios de autentificación:
•
Local Domains usa la base de datos local de usuarios para la autentificación. El
parámetro opcional UserGroup puede usarse para restringir la verificación a un grupo
específico de usuarios. Este dominio es soportado por ambas versiones de REMBO
(Windows NT y Unix).
Prácticas de Empresa 2001/02 1er Turno
Página 24
Manual de Administración del Servidor
•
•
Remote NT Domains envía la petición de autentificación al servidor NT especificado
en el parámetro AuthServerName. El parámetro opcional UserGroup puede usarse
para restringir la verificación a un grupo específico de usuarios. Este dominio es
soportado solamente por la implementación Windows NT del Rembo.
Radius Domain envía la petición de autentificación a un dispositivo Radius
especificado en AuthServerAddress. El valor del parámetro RadiusSecret es usado
como el secreto en la comunicación por Radius y debe coincidir con la palabra secreta
almacenada en la configuración del dispositivo Radius para que el protocolo funcione.
Nota: para los clientes puedes usar dominios de autentificación con los asistentes (wizards) o
con las funciones LogonUser y Logon de REMBO-C.
2.4.-Túneles TCP
Un Túnel TCP es una forma de proveer conectividad TCP en clientes REMBO. Un túnel TCP
define un nombre de servidor y un puerto que se hace accesible para clientes REMBO a través
de clientes específicos Rembo-C.
Los túneles TCP pueden usarse para proveer de un amplio rango de interesantes
aplicaciones por parte del cliente. Algunos ejemplos:
•
•
•
•
Acceder a un servidor SMTP para mandar correo a un administrador si se ha detectado
algún fallo en el REMBO.
Acceder a servidores de base de datos (a través de una puerta de enlace TCP-toODBC) para obtener información o instrucciones de qué tipo de operación ejecutar, o
almacenar información sobre el ordenador (inventario de hardware).
Acceder a un servidor HTTP (servidor web) para extraer información directamente de la
World Wide Web.
Acceder a herramientas de gestión o a un interface con métodos de autentificación
específicos.
Si trabajas en una configuración basada en ficheros debes añadir los túneles TCP al principio
del fichero de configuración, antes del primer grupo del servidor. La definición del túnel TCP se
hace como sigue:
TCPTunnel Identificador (palabra que usarán los clientes para identificar el túnel).
Ejemplo: un túnel TCP llamado sendmail que permite el envío de correo electrónico a la World
Wide Web:
TCPTunnel sendmail {
RemoteHost “mail.company.com”
RemotePort 25
}
Si usa configuración basada en registros puede crear los túneles TCP desde la consola del
servidor. Elija Añadir túnel en el menú pinchando con el botón derecho en el árbol del servidor.
Introduzca su identificador, un nombre de servidor (o dirección IP) y un puerto.
Guía de referencia rápida para los túneles TCP:
•
RemoteHost es una cadena que representa el host remoto (nombre o dirección IP)
TCP con el cuál contactar cuando el cliente Rembo abre este túnel TCP. Si trabajamos
en un servidor basado en ficheros, el nombre o IP del host debe ir entre comillas.
Prácticas de Empresa 2001/02 1er Turno
Página 25
Manual de Administración del Servidor
•
RemotePort es el puerto al cuál se conectará el cliente Rembo. Puedes obtener una
lista completa de puertos válidos en el fichero /etc/services en una máquina Unix o en
el fichero /winnt/system32/drivers/etc/services en una máquina Windows NT.
Nota: El cliente accede a los túneles TCP mediante las funciones: TCPConnect, TCPRead
TCPWrite y TCPClose.
2.5.- Grupos de servidor (Host groups)
Los grupos de servidor se usan para organizar los ordenadores en pequeñas unidades. Cada
unidad tiene sus propios parámetros. Un grupo de servidor en REMBO consta de 2 partes:
•
•
Parámetros, como la página HTML de inicio o el dominio de autentificación que usará.
Una lista de servidores contenidos en ese grupo. Estos hosts usarán los parámetros
genéricos definidos para el grupo o puede tener parámetros específicos al servidor.
Habitualmente solo se modificarán los parámetros StartPage y Options.
2.5.1.- El grupo por defecto (default)
Existe un grupo especial, conocido como default. No requiere lista de servidores y lo utiliza el
servidor cuando se conecta un ordenador que no pertenece a ningún grupo. Si no existe el
grupo default la conexión es rechazada. Este grupo resulta una opción especialmente
interesante en cuestiones de seguridad ya que se puede borrar y dejar exclusivamente grupos
definidos por el administrador con parámetros determinados, rechazando conexiones de
clientes que no pertenezcan a ningún grupo.
Si trabaja en una configuración basada en registros puede añadir nuevos grupos desde la
consola del servidor: pincha en Parámetro, elija Añadir Grupo en el menú Añadir / Eliminar.
Aparecerá un cuadro de diálogo solicitando los valores del grupo. Ningún campo es obligatorio
y pueden dejarse en blanco. Posteriormente puede borrarse un grupo si se desea.
En la configuración basada en ficheros puede añadir nuevos grupos insertando la orden
Group nombre en el fichero de configuración.
Guía rápida de referencia para los parámetros de grupos de servidor
Se pueden definir a nivel de grupo (antes de la lista de servidores en una configuración
basada en ficheros) o a nivel de servidor (para cada entrada Host o HostRange).
•
•
•
•
•
Fileserver dirección_ip : Dirección IP del servidor que suministra los protocolos NTEfs,
FAST y MCAST (leer el manual para más información).
RemoteConsole dir_ip:puerto : Dirección IP y puerto para la consola remota de
aplicación, y ordena al Rembo que contacte con la consola remota al próximo arranque
(leer el manual para más información).
Options [admin][, autoboot][, novesa][, unicast] : estos parámetros definen el modo de
operación de REMBO (leer el manual para más información).
Lockout [none][, poweroff][, reset][, mouse][, keys][, screen][, all] : pueden usarse para
bloquear algún periférico determinado durante el tiempo que REMBO está activo en el
cliente (leer el manual para más información).
AuthDomain “dominio” : Este es el dominio de autentificación cuando uno de los
grupos de servidor necesita comprobar la identidad de un usuario (leer el manual para
más información).
Prácticas de Empresa 2001/02 1er Turno
Página 26
Manual de Administración del Servidor
•
•
•
StartPage “ruta” : Página de inicio del cliente (leer el manual para más información).
Host dirección_ip y Host dirección_hardware : Valores de cada servidor en la lista de
servidores (leer el manual para más información).
HostRange startip->endip : Rango de servidores (leer el manual para más
información).
Prácticas de Empresa 2001/02 1er Turno
Página 27
Manual de Administración del Servidor
CAPÍTULO 3 :
servidor REMBO
Herramientas
administrativas
del
Las dos herramientas utilizadas para administrar el servidor REMBO son : NetClnt, una
utilidad de línea de comando para acceder a los ficheros del servidor, y la Consola del
Servidor, una aplicación de Windows para administrar todos los aspectos del servidor REMBO
con Windows NT.
3.1.- Netclnt
NetClnt es una utilidad de línea de comando disponible para Windows, Linux y Solaris. Se
usa para acceder remotamente a los ficheros del servidor REMBO.
Algunas de las características de NetClnt son:
•
•
•
•
Las comunicaciones entre NetClnt y el servidor están protegidas con un password y
encriptado.
NetClnt puede ser usado de forma interactiva o en modo batch.
Los ficheros pueden ser borrados, renombrados, movidos, descargados y subidos. Los
directorios pueden ser sólo borrados, renombrados y movidos.
Los ficheros son descargados con el protocolo NETfs y cargados con el protocolo
FAST.
3.1.1.- NetClnt Interactivo
Simplemente hay que ejecutar el fichero netclnt en el directorio misc que se encuentra dentro
del directorio de instalación de REMBO. Verás el prompt NETFS>. Puedes utilizar los
comandos interactivos de NetClnt pero lo primero que tienes que hacer es abrir una conexión
con el servidor REMBO.
3.1.1.1.- Primer paso: conexión con el servidor REMBO
Para abrir una conexión con el servidor REMBO hay que usar el comando open seguido de la
dirección IP (o hostname) del servidor. A continuación te pedirá un password que es el mismo
que le pusimos en el fichero de configuración (rembo.conf) en el parámetro global
NetPassword.
Usando el comando open no se generará tráfico en la red.
3.1.1.2.- Segundo paso: comprobación de la conexión
Para comprobar la conexión se utilizará el comando dir. Este comando descargará y mostrará
el contenido del directorio actual en el servidor remoto.
3.1.1.3.- Tercer paso: experimentando con la conexión
Ya se puede usar cualquier comando de NetClnt. Puedes enviar un nuevo fichero al servidor
(put), cambiar el directorio actual (cd) u obtener localmente un fichero del servidor (get). Hay
Prácticas de Empresa 2001/02 1er Turno
Página 28
Manual de Administración del Servidor
que tener en cuenta que si quiere enviar un fichero al servidor éste debe existir en tu ordenador
local en el directorio actual (para cambiar el directorio actual local se utiliza lcd).
3.1.2.- Usando NetClnt en modo batch
Para usar NetClnt en modo batch crearemos un fichero de texto con la secuencia de
comandos que queremos que se ejecuten con NetClnt y ejecutar netclnt filename donde
filename es el nombre del fichero de texto que hemos creado con la lista de comandos. El
primer comando debe ser open con una dirección de IP válida y un password válido (el
password puede ser pasado como tercer parámetro del comando open).
Ejemplo del modo Batch :
open 192.168.1.10 rembopwd
mkdir /myfiles
cd /myfiles
put file1
put file2
put file3
exit
3.1.3.- Comandos de NetClnt
•
open host [password] / connect host [password]
Este comando es el primero que se deberá utilizar porque es el que hace que comience
la conexión de información requerida para acceder remotamente al servidor REMBO.
Es recomendable poner el password en la línea de comando porque si no lo
especificamos ahora nos será pedido más tarde.
•
dir [path] / ls [path]
Muestra el contenido de un directorio del servidor remoto. Si no se especifica ningún
parámetro el directorio que se muestra es el actual.
•
cd path / chdir path
Cambia el directorio actual remoto. Al comenzar NetClnt el directorio actual es el root
del sistema de ficheros del servidor. El path es el relativo al directorio actual remoto.
•
md path / mkdir path
Crea un nuevo directorio en el servidor.
•
rd path / rmdir path
Borra un directorio del servidor. El directorio debe estar vacío.
•
deltree path
Borra un directorio remoto y todos sus subdirectorios. Este directorio no tiene que
estar vacío pero USA ESTE COMANDO CON PRECAUCIÓN.
Prácticas de Empresa 2001/02 1er Turno
Página 29
Manual de Administración del Servidor
•
pwd
Muestra el directorio remoto actual.
•
ren old-name new-name / move old-name new-name
Renombra o mueve un fichero del servidor. El nuevo fichero y el antiguo deben ser
especificados.
•
del path / rm path
Borra un fichero del servidor.
•
lcd path
Cambia el directorio actual del ordenador local. Este comando no tiene efectos sobre
el servidor. Sólo modifica el directorio actual del ordenador que arranca NetClnt.
•
!localcommand
Ejecuta un comando en el ordenador local. Por ejemplo, !dir muestra el contenido del
directorio actual del ordenador local. !edit myfile edita el fichero myfile con el editor de
MS-DOS.
•
get remote-path [local-path] / mget pattern
Descarga el fichero remoto remote-path desde el directorio remoto actual en el fichero
local-path dentro del directorio local actual. Si el segundo parámetro es omitido el
fichero se cargará bajo el nombre de remote-path. Mget descarga todos los ficheros
remotos que se correspondan con el patrón pattern al directorio local.
•
put local-path [remote-path] / mput pattern
Carga el fichero local local-path desde el directorio actual local sobre el fichero remotepath en el directorio actual remoto. Si el segundo parámetro es omitido el fichero se
carga bajo el nombre de local-path en el servidor. Mput carga todos los ficheros que se
correspondan con el patrón pattern al directorio remoto.
•
wake hardware-address
Envía un paquete wake a la dirección hardware especificada. El ordenador al que se le
envía dicho paquete debe encontrarse en la misma red que el ordenador en el que se
está ejecutando NetClnt. También, dicho ordenador debe permitir wake-on-lan desde
la tarjeta de red. La dirección hardware no debe tener ningún delimitador. Por ejemplo,
la dirección hardware 00:10:4B:12:34:56 debe ser puesta en el comando wake como
00104B123456.
Prácticas de Empresa 2001/02 1er Turno
Página 30
Manual de Administración del Servidor
•
sleep sleeptime
Espera sleeptime segundos. No se ejecuta ningún comando durante este tiempo. Este
comando es utilizado en los batch scripts.
•
getlock lockname / releaselock lockname
Realiza un servidor de cierre. Éste es identificado por un nombre (lockname).
3.2.- Consola del servidor
Esta sección da instrucciones sobre el uso de la aplicación de consola del servidor REMBO,
disponible para Windows NT.
3.2.1.- Introducción
SConsole es una poderosa aplicación para administrar el servidor REMBO. Puede ser usado
para:
•
•
•
•
•
•
•
control del estado operativo del servidor.
iniciar, parar y reiniciar el servidor.
modificar los parámetros de configuración remotamente.
crear accesos a host y accesos a grupos.
cargar ficheros desde y al sistema de ficheros del servidor.
mirar los ficheros log del servidor.
editar variables constantes.
Todas estas operaciones pueden ser ejecutadas sobre un servidor REMBO local, o sobre un
servidor remoto.
La consola del servidor debe ser ejecutada como un administrador local o como un usuario
con suficientes privilegios para acceder al registro en modo lectura / escritura.
3.2.2.- La interfaz
La interfaz de la consola del REMBO es similar al explorador de Windows. A la izquierda
podrás ver a los servidores y temas de configuración (parámetros, ficheros...) y a la derecha
verás todos los elementos correspondientes al tema activado en el panel de la izquierda. Cada
nivel de jerarquía tiene sus propios elementos y sus propias acciones. Puedes usar el botón
de la derecha para mostrar un menú contextual basado en la localización actual que tiene en la
jerarquía.
3.2.3.- Añadir un servidor
Para añadir un nuevo servidor a la lista de servidores (en la parte izquierda de la ventana
principal), elija añadir servidor desde el menú Add/Remove o click con el botón derecho del
ratón sobre el icono del servidor del REMBO en la parte de arriba de la lista mostrada a la
izquierda del panel: {bmct bmp/rembo.bmp}
Prácticas de Empresa 2001/02 1er Turno
Página 31
Manual de Administración del Servidor
SConsole soporta tres tipos diferentes de servidores: servidor local, servidor remoto NT y
servidor remoto no-NT.
3.2.3.1.- Servidor local
Este tipo de servidor se usa cuando el servidor y la consola están ejecutándose en el mismo
ordenador. La consola mirará en el registro local NT para buscar y editar los parámetros del
servidor. Por defecto, un icono para el servidor local es añadido cuando Sconsole comienza si
un servidor local ha sido detectado.
3.2.3.2.- Servidor remoto NT
Se usa cuando se utiliza un servidor REMBO remoto (no se encuentra en el mismo ordenador
que la consola). La consola usará Windows NT para abrir el sistema de registros sobre el host
remoto. Esto significa que debe tener suficientes privilegios para abrir y escribir en el registro
sobre el ordenador remoto.
3.2.3.3.- Servidor remoto sin NT
Si el servidor REMBO se ejecuta bajo Linux o Solaris, se usa este tipo de servidor para
acceder a los ficheros del servidor. La consola no puede leer o escribir la configuración de un
servidor Linux/Solaris remotamente.
3.2.4.- Estado del servidor
Puedes ver el estado del servidor REMBO haciendo click sobre el icono de estado que se
encuentra debajo del icono del servidor en la parte izquierda del panel.
La primera línea de la parte derecha del panel muestra el actual estado del servidor. Puede
mostrar uno de estos valores:
•
RUNNING: el servidor está operativo y ejecutándose.
•
STOPPED: el servidor no se está ejecutando.
•
START_PENDING: el servidor está intentando comenzar.
•
STOP_PENDING: el servidor está intentando parar.
3.2.5.- Arrancando el servidor
Si el estado del servidor es STOPPED, puedes arrancar el servidor REMBO haciendo click
con el botón derecho del ratón sobre la línea del estado STOPPED en la parte derecha del
panel y eligiendo la opción Start Server, o simplemente elegir la opción Start Server desde el
menú del servidor.
Prácticas de Empresa 2001/02 1er Turno
Página 32
Manual de Administración del Servidor
3.2.6.- Parando el servidor
Si el estado del servidor es RUNNING, puedes parar el servidor REMBO haciendo click con el
botón derecho del ratón sobre la línea del estado RUNNING en la parte derecha del panel y
eligiendo la opción Stop Server, o simplemente elegir la opción Stop Server desde el menú del
servidor.
3.2.7.- Recargando la configuración del servidor
Para ello solamente tenemos que hacer click con el botón derecho del ratón sobre la línea de
estado en la parte derecha del panel y elegir la opción Restart server o elegir Restart server en
el menú del servidor.
Este comando fallará si el estado del servidor no es RUNNING.
3.2.8.- Modificación de los parámetros
Puedes usar la consola del servidor para modificar los parámetros globales, autentificación de
dominios y grupos de host. Para completar la descripción de dichos parámetros véase capítulo
2.
Los parámetros son accesibles sólo si el servidor es un servidor local o un servidor remoto
NT. Por lo tanto, puedes acceder a todos los parámetros desde el icono Parameters :
•
Los parámetros básicos son accesibles directamente desde la sección Parameters.
•
Los parámetros globales se encuentran dentro de la sección Parameters\Advanced.
•
Los dominios de autentificación los podemos encontrar dentro de la sección
Parameters\AuthDomains
•
Y por último, los grupos de host se encuentran en la sección Parameters\Groups
Podemos cambiar cualquiera de estos parámetros haciendo click sobre estos nombres con el
botón derecho del ratón sobre la ventana derecha y seleccionando Modify en el menú
contextual.
3.2.9.- Modificación de las variables
Puedes añadir, modificar o borrar las variables persistentes desde la consola del servidor.
Estas variables están definidas en la sección 3.3 del manual para clientes REMBO.
El acceso a estas variables esta limitado para el servidor local y servidor remoto NT.
Una variable persistente puede ser global, local a un grupo o local a un host. Las variables
globales se encuentran en la sección Parameters\Variables. La ventana derecha muestra la
lista de variables ya definidas. Para añadir una nueva variable, hacemos click con el botón
derecho del ratón en la ventana derecha y seleccionamos New integer variable, New string
variable o New boolean variable en el menú contextual. Puedes modificar éstas en las
variables haciendo click con el botón derecho del ratón sobre ellas en la ventana derecha y
seleccionar Modify en el menú contextual. Para borrar una variable también tenemos que hacer
click sobre el nombre de la variable con el botón derecho del ratón y elegimos Delete en el
menú contextual.
Prácticas de Empresa 2001/02 1er Turno
Página 33
Manual de Administración del Servidor
Para acceder a las variables locales a un grupo específico de hosts, haz click en el icono
Variables debajo del icono de grupo que quieres modificar en el árbol de directorios. El resto es
como se ha indicado para las variables globales.
Las variables locales a un host son accesibles en el icono Variables bajo el icono de host de
la entrada de host que se quiera modificar.
3.2.10.- Ver los ficheros de log
La consola permite acceder a los ficheros log creados por el servidor durante su ejecución.
Estos ficheros contienen información muy útil cuando se tiene la sospecha de que algo va mal.
Hay tres ficheros log que pueden ser vistos desde la consola:
•
Boot Log, el cual contiene información acerca del servicio PXE Proxy, del servicio
PXE Boot Discovery y del servicio MTFTP.
•
NBP log, el cual contiene información acerca de los parámetros de grupo y host, de
autentificación y del dominio NT.
•
File log, el cual contiene información acerca de todos los ficheros multicast y unicast
transferidos entre el REMBO y el servidor.
Para mirar un fichero log debemos hacer doble click sobre el nombre del fichero en el panel
derecho. El contenido del fichero será mostrado con el editor Rembo Quick. Los ficheros log
son de sólo lectura.
3.2.11.- Acceso a los ficheros del servidor
El explorador del sistema de ficheros de la consola trabaja como el explorador de Windows.
Los comandos esenciales (delete, copy, paste, makedir) están disponibles en el menú
contextual que aparece cuando hacemos click con el botón derecho del ratón sobre el objeto
que queramos en el panel derecho. Este panel se refresca con F5.
3.2.12.- Preguntas más frecuentes
•
P : Quiero salvar mi fichero con el editor Rembo Quick y la consola me muestra un
tamaño 0.
•
R : Presiona F5 para refrescar.
•
P: No puedo cargar ni descargar desde el explorador de la consola...
•
R: Algunas versiones de Windows NT parece que tienen problemas con la carga y
descarga. Usa download en el menú del fichero.
•
P:¿Dónde está la función SaveAs en el editor Rembo Quick?
•
R: No existe. Copia el fichero con copy/paste antes de editarlo.
Prácticas de Empresa 2001/02 1er Turno
Página 34
Manual de Administración del Servidor
CAPÍTULO 4 : Despliegue de REMBO en la empresa
Este capitulo describe las características necesarias en grandes corporaciones o instituciones.
La tolerancia a fallos añade robustez a su infraestructura de arranque remoto, mientras la
distribución de ficheros es la manera ideal de distribuir imágenes de disco duro a múltiples
servidores REMBO. Tenga en cuenta que el modulo de distribución de ficheros solo está
disponible en la edición Enterprise de REMBO.
4.1.- Tolerancia a fallos
Un sistema es tolerante a fallos si es capaz de continuar trabajando cuando una de las partes
falla. En el caso de servidores REMBO, el sistema entero es tolerante a fallos si los servidores
REMBO están respaldándose unos a otros. Cuando un servidor falla, otros servidores manejan
las peticiones enviadas al servidor que ha caído.
Tenga en cuenta que implementar tolerancia a fallos en el ámbito de REMBO no significa que
su infraestructura de red sea tolerante a fallos. Usted está obligado a implementar tolerancia a
fallos a todos los niveles:
•
•
•
•
•
•
A nivel físico, teniendo fuentes de alimentación redundantes (si todos los servidores
REMBO se quedan sin energía eléctrica a la vez, la tolerancia a fallos a nivel REMBO
es inútil);
A nivel de red, teniendo enlaces de red de respaldo, y elementos activos de copia de
seguridad (el servidor de copias de seguridad debe ser capaz de alcanzar a los clientes
de arranque remoto);
A nivel de sistema operativo de red, teniendo múltiples dominios de red, o teniendo
servidores REMBO funcionando fuera de su arquitectura de dominios (p.e. los
servidores REMBO nunca deberían estar todos enlazados al mismo PDC NT, o al
mismo servidor NFS);
A nivel DHCP, teniendo múltiples servidores DHCP en la misma subred;
A nivel REMBO, implementando las instrucciones de tolerancia a fallos encontradas en
este capítulo;
Finalmente, a nivel de sistema operativo. Si REMBO es capaz de sobrevivir a un
problema severo, pero el sistema operativo no es capaz de encontrar su servidor de
red, la tolerancia a fallos es inútil.
Aquí veremos como implementar la tolerancia a fallos a niveles DHCP y REMBO. Los otros
niveles están fuera del ámbito de este documento.
4.1.1.- Tolerancia a fallos a nivel DHCP
El protocolo DHCP ha sido diseñado de forma que permita implementar tolerancia a fallos y
balanceo de carga fácilmente. Si dos servidores DHCP están conectados a la misma subred IP,
y ambos servidores están configurados para entregar direcciones IP en la subred, el protocolo
manejará todos los conflictos entre los dos servidores.
Cuando un cliente remoto hace una petición de dirección IP, la petición es enviada a la
dirección broadcast local, es decir, a todos los hosts conectados a la misma subred IP que el
cliente remoto. Si uno o más servidores DHCP están conectados a la subred, ellos enviarán un
paquete de ofrecimiento DHCP al cliente remoto, conteniendo una dirección IP almacenada en
la lista de direcciones disponibles en el servidor, o asignadas por el administrador al cliente
remoto. Si más de un paquete de ofrecimiento DHCP es recibido por el cliente remoto, sólo el
"más informativo" será conservado por el cliente. Por "informativo", queremos decir que
ofrezcan suficiente información PXE para avanzar en la resolución PXE.
Prácticas de Empresa 2001/02 1er Turno
Página 35
Manual de Administración del Servidor
Cuando un cliente remoto ha seleccionado una oferta válida, contesta al servidor desde donde
se originó el paquete broadcast. Este paquete es recibido por todos los hosts conectados a la
subred local, incluyendo los servidores DHCP. Este paquete es usado por los servidores DHCP
para saber si sus ofertas han sido aceptadas o rechazadas por el cliente remoto. Si la oferta ha
sido aceptada, la dirección IP es bloqueada en la base de datos del servidor DHCP, y el
proceso DHCP puede continuar en modo unicast entre el cliente remoto y el servidor DHCP. Si
la respuesta es para otra oferta, el servidor liberará la dirección IP que ofreció, y bloqueará la
dirección IP enviada en la contestación de la oferta, para marcar la dirección IP como usada en
la subred local.
Usted puede además implementar tolerancia a fallos configurando múltiples servidores DHCP
para la misma subred. Si los servidores DHCP están configurados de manera idéntica,
entonces los clientes remotos siempre seleccionarán la primera oferta, o sea, la que venga del
servidor más rápido. Esto puede ser usado para implementar balanceo de carga a la vez que
tolerancia a fallos: el servidor más rápido siempre es seleccionado, y si el servidor más rápido
se sobrecarga, será otro el que envíe las ofertas más rápido, y llegará a ser el servidor más
rápido.
4.1.2.- Tolerancia a fallos a nivel REMBO
La tolerancia a fallos a nivel REMBO está implementada con dos parámetros de
configuración: Backup y BootReplyDelay.
Para comprender como está implementada la tolerancia a fallos a nivel REMBO, debe
recordar que el proceso de arranque es hecho en varias fases: resolución DHCP, resolución
PXE, descarga MTFTP y finalmente REMBO. La tolerancia a fallos a nivel DHCP es descrita en
la sección previa. La tolerancia a fallos a nivel PXE puede conseguirse usando múltiples
servidores REMBO en modo Proxy DHCP (p.e. no hay servidor REMBO en la maquina servidor
DHCP, pero todos los servidores REMBO están conectados a la subred). En modo Proxy
DHCP, los servidores REMBO enviarán paquetes de contestación PXE al paquete de
resolución DHCP inicialmente enviado por el cliente remoto. Como los paquetes de resolución
DHCP son enviados a las direcciones broadcast, todos los servidores REMBO recibirán la
resolución, y enviarán un paquete de contestación, con las siguientes consideraciones:
•
•
El cliente remoto debe ser conocido por el servidor (siendo miembro de un grupo en la
configuración del servidor, o si la configuración contiene un grupo por defecto);
El servidor no contestará inmediatamente si el parámetro BootReplyDelay está puesto.
Puede usar BootReplyDelay para introducir preferencias de orden en la misma subred. El
servidor con el BootReplyDelay más bajo (o sin BootReplyDelay puesto) será el primero en
contestar a los paquetes de resolución DHCP. Todos los clientes remotos serán
redireccionados a este servidor. Pero si el servidor falla, el servidor con el segundo valor de
BootReplyDelay más bajo será el primero en contestar, y así sucesivamente. La tolerancia a
fallos a nivel resolución PXE está aquí.
Si varios servidores REMBO (o todos) tienen el mismo valor para el parámetro
BootReplyDelay, ellos enviarán la contestación PXE a la vez, y el cliente remoto seleccionará el
primero, o el servidor más rápido. Este entorno específico puede ser usado para implementar
carga balanceada a nivel REMBO.
Una vez el cliente remoto ha seleccionado su servidor DHCP y PXE, la secuencia de inicio
REMBO puede ser descargada desde el servidor PXE (servidor REMBO), y el cliente REMBO
iniciado. Puede implementar tolerancia a fallos dentro de REMBO usando el parámetro Backup
para especificar un servidor de respaldo. Este valor será enviado al cliente remoto durante el
arranque inicial del cliente REMBO, y será usado como servidor de respaldo si el servidor
primario falla. El protocolo interno de red usado en REMBO ha sido diseñado para permitir al
Prácticas de Empresa 2001/02 1er Turno
Página 36
Manual de Administración del Servidor
cliente cambiar del servidor primario al de respaldo en mitad de una transferencia de ficheros.
Sin embargo, esto solo funciona bajo las siguientes consideraciones:
•
•
Los ficheros abiertos en modo escritura (subidos al servidor) no pueden ser cambiados
a un servidor de respaldo. Esto puede ocasionar corrupción de datos en el servidor,
porque una parte del fichero puede ser escrito en el servidor primario, y la otra parte en
el servidor de respaldo;
La estructura del sistema de ficheros en los servidores primarios y de respaldo debe
ser estrictamente idéntica (p.e. el mismo contenido bajo el directorio files del servidor).
Sugerimos usar servidores de respaldo a nivel REMBO (con el parámetro Backup) cuando
haya estabilizado su sistema (imágenes de disco duro realizadas, scripts listos). Una vez todo
está estabilizado en el servidor principal, copie el directorio files del servidor primario al servidor
de respaldo, y ajuste el parámetro Backup en el servidor principal.
4.2.- Front-end de la distribución
El front-end de la distribución solo está disponible para la edición Enterprise de REMBO.
Prácticas de Empresa 2001/02 1er Turno
Página 37
MANUAL DE ADMINISTRACIÓN DEL
CLIENTE
Manual de Administración del Cliente
CAPÍTULO 1 : Conceptos sobre REMBO
Si ya estas familiarizado con programas de arranque remoto, puedes saltarte este capítulo y
saltar directamente al capítulo 2.
1.1.- ¿Qué es Rembo?
Rembo es un programa de arranque remoto PXE. Este tipo de programas se diferencia de
cualquier otro por varias razones:
•
•
•
•
•
Se le llama durante el arranque del ordenador, antes que a ningún sistema operativo o
administrador de arranque de disco.
Depende de la presencia de un chip especial en la tarjeta de red, la Boot Rom.
Es capaz de usar la red gracias a una interfaz facilitada por la boot rom. PXE es el
estándar de facto para este tipo de interfaz.
Se baja de un servidor especial de arranque, y no depende de ningún dispositivo de
almacenamiento local. Puede trabajar en ordenadores sin disco duro o sin unidad de
disquete. Si los tiene puede usarlos, pero el arranque no fallará si estos dispositivos sí
lo hacen.
Consigue sus parámetros (dirección IP y otros parámetros de arranque) de un servidor
DHCP.
Una vez comenzado se comporta como un mini-Sistema Operativo. Puede ejecutar varias
operaciones, que pueden ser divididas en cuatro categorías: Operaciones de fichero, de red, de
interfaz de usuario y de sistema. Algunas de las operaciones más útiles son:
•
•
•
•
•
•
Autentificación de usuarios.
Acceso a ficheros independientemente del SO : Rembo puede acceder a sistema
de ficheros NTFS, FAT, EXT2.
Interfaz HTML.
Imágenes de disco : esta característica se puede usar para “clonar” sistemas
operativos o para restaurar sistemas inestables.
Sistema de fichero de red : el servidor de Rembo es un poderoso software multitarea
con su propio sistema de archivos. Los ficheros del servidor pueden ser cargados por
el cliente ejecutando Rembo.
Agrupar ordenadores : los ordenadores se pueden agrupar en el fichero de
configuración del servidor para compartir las mismas opciones de arranque. Cada
ordenador o grupo de ordenadores pueden tener sus propias opciones.
1.2.- ¿ Cómo trabaja ?
Una secuencia típica de arranque remoto sigue las siguientes fases.
•
•
Encendido : el ordenador con arranque remoto se enciende, tanto por un usuario
como por un evento programado.
Obtención de la dirección IP : el cliente remoto hace una petición DHCP para
conseguir su IP. Cualquier servidor DHCP que conozca al cliente (es decir, reconozca
su dirección ethernet) o que tenga direcciones IP dinámicas libres le envía una
dirección IP.
Prácticas de Empresa 2001/02 1er Turno
Página 40
Manual de Administración del Cliente
•
•
•
•
Descubrimiento del servidor de arranque : el servidor de arranque es el encargado
de servir el programa de arranque al cliente. No tiene que ser necesariamente la misma
máquina que el servidor DHCP. El cliente responderá al primer servidor de arranque
que le conteste, y se bajará un pequeño programa de arranque usando un protocolo
multicast (MTFTP).
Conexión BNP : con este servicio el cliente obtiene la información de cómo tiene que
ser configurado.
Configuración Pre-SO : Rembo, entonces, descargará un fichero del servidor de
arranque con todo lo que es necesario para llevar a cabo una configuración específica
del administrador del sistema.
Arranque del SO : Rembo se borra de la memoria y deja al ordenador iniciar el SO,
como si el ordenador estuviera arrancando normalmente del disco duro. Esto
asegurará una compatibilidad total con los sistemas operativos.
El servidor Rembo debe estar siempre disponible para el cliente, pero para el caso de graves
fallos en la red, los clientes Rembo se pueden configurar para trabajar en modo off-line, es
decir, sin acceso a la red.
1.3.- Requisitos para el sistema cliente
El cliente arranque remoto debe estar equipado con un bootrom PXE. Recomendamos
comprar tarjetas de red actualizables para poderlas actualizar con la ultima versión PXE
disponible. Actualmente la mejor implementación de PXE está en las tarjetas de red de Intel.
3COM, IBM y RealTek también lo suministran.
Prácticas de Empresa 2001/02 1er Turno
Página 41
Manual de Administración del Cliente
CAPÍTULO 2: Comenzando a usar REMBO
A lo largo de este capítulo descubriremos como trabaja Rembo, qué tipo de tareas puede
ejecutar y cómo controlar el comportamiento de cada ordenador usando Rembo.
2.1.- Arrancando Rembo por primera vez
La pantalla de Rembo se divide en dos partes: el escritorio y la barra de herramientas. El
contenido del escritorio esta determinado por una página HTML almacenada en el servidor. Por
defecto este fichero se llama rembo.shtml, pero es posible configurar un fichero diferente para
uno o varios ordenadores. Puedes personalizar libremente el aspecto de Rembo editando este
fichero. La barra de herramientas tiene un menú a la izquierda que también puedes
personalizar.
Atención : Durante tu exploración de Rembo, asegúrate que lo estás ejecutando en modo
Administrador. La barra de menú debería tener al menos 4 opciones, incluido una que se llama
Interact... Si no es el caso debes activar el modo administrador para esta máquina. Si estás
usando un servidor Linux, puedes hacerlo añadiendo una línea como :
Options admin
al comienzo de la definición de grupo en el fichero rembo.conf y manda una señal kill –HUP al
servidor.
A menos que se configure de otra forma, Rembo comienza un asistente interactivo al
arrancar. Muestra la información del cliente en la parte superior derecha y un menú emergente
que te permite experimentar las características básicas de Rembo.
2.1.1.- Cambiar la página de comienzo
Tienes varias posibilidades para editar la página HTML del escritorio.
•
•
•
Editándola usando el editor de texto de Rembo, tecleando el siguiente comando en el
“Evaluador interactivo”: TextEdit(“net//global/rembo.shtml”);
Editándola en el servidor usando la consola de administración del servidor (la consola
solo se ejecuta bajo Windows).
Editándola en cualquier ordenador y luego descargarla usando el programa netclnt.
2.1.2.- Mostrar la consola Rembo
Si cometes errores en tus scripts, por ejemplo, puedes querer comprobar la consola local para
un detallado informe de otros mensajes informativos. Para hacer esto, usa la opción Show
console en la barra de menú. Esto abrirá una ventana con todos los sucesos de interés.
También puedes leer ahí si Rembo sé esta ejecutando en modo Administrador o no.
Puedes probar a hacer que la ventana de la consola aparezca por sí misma editando el
fichero rembo.shtml y reemplazando el HideConsole() por ShowConsole().
Prácticas de Empresa 2001/02 1er Turno
Página 42
Manual de Administración del Cliente
2.2.- Experimentando con los scripts de Rembo
El modo interactivo de Rembo te permite evaluar expresiones simples una por una y ver los
resultados inmediatamente en la consola. Este modo es muy útil para comprobar comandos
individuales que serán luego incluidos en los scripts.
2.2.1.- Arrancar el evaluador interactivo
El evaluador interactivo está disponible desde el menú de inicio cuando el cliente esta
configurado en modo administrador.
2.2.2.- Funciones básicas
Con la consola de REMBO visible, pruebe a evaluar los siguientes comandos :
•
•
•
•
•
Log(“Hello <I>world<I>”); Imprime en la consola el texto entrecomillado.
Keyb(“es”); Carga el mapa de teclado del país seleccionado.
Log(GetPrimaryPartitions(0)); Muestra el contenido de la primera tabla de particiones
de tu primer disco duro
str part = Get PrimaryPartitions(0); esto hace lo mismo pero en lugar de mostrarlo
por la consola, lo guarda en la variable part.
PowerOff();
2.2.3.- Funciones de disco
Atención : los comandos que se muestran a continuación acceden al contenido de tu disco
duro. No usarlos en ordenadores con información útil en los discos.
•
•
•
•
•
•
SetPrimaryPartitions(0,”FAT16:200000”);
Este comando cambiará la tabla de particiones, y creará una única partición FAT16 de
200 MB. Solo cambia la tabla, no formatea.
HDClean(0.0);
Este comando limpia el master boot record (MBR) del primer disco duro.
HDClean(0,1);
Hace un formateo rápido de la primera partición del primer disco duro. En este caso
creará una partición vacía de 200MB con FAT16
CreateTextFile(“disk://0:1/greetings.txt”,”From Rembo”);
Este comando crea un fichero de texto llamado greetings.txt en el directorio raíz de la
partición recién formateada. El nombre del fichero se da en formato URL.
CreateDir(“disk://0:1/temp”);
Crea un nuevo directorio llamado temp.
FloppyBoot();
Permite al ordenador arrancar desde un disquete, por ejemplo, para instalar un sistema
operativo manualmente o para verificar que Rembo ha hecho realmente lo que se
supone que hace.
Por supuesto, el objetivo de Rembo no es formatear los discos duros y/o reinstalar un sistema
operativo manualmente. En la sección 3.4 aprenderemos a usar imágenes de disco para
automatizar la instalación de sistemas operativos y cómo configurarlo automáticamente.
Prácticas de Empresa 2001/02 1er Turno
Página 43
Manual de Administración del Cliente
CÁPITULO 3 : Trabajando con REMBO
A lo largo de este tema vamos a tratar los siguientes temas :
•
•
•
•
•
•
•
•
Acceso a ficheros bajo REMBO (URLs).
Uso de la pseudo-partición caché de disco.
Imágenes de discos-floppy y discos-Ram.
Creación y restauración de imágenes de discos duros (clonación).
Personalización del sistema destino (registros y parches)
Autentificación de usuarios.
Escribir tus propios scripts de REMBO.
Arrancar REMBO sin conexión a red.
3.1.- Acceso a ficheros mediante REMBO
Todos los ficheros y directorios se identifican mediante una URL. Una URL es como un path,
excepto que añade dos campos junto al path. Estos dos campos permiten que el recurso sea
globalmente localizado.
Un URL Rembo tiene tres campos:
•
Tipo o prefijo: indica el método usado para encontrar el recurso especificado.
disk
floppy
cdrom
ram
net
cache
reg
arch
link
display
loop
var
Disco duro local
Unidad de disco floppy local
Disco CD-Rom
Discos Ram de Rembo
Fichero remoto, accedido a través de NETfs
Fichero remoto, accedido a través de la partición
caché local
Registro Windows NT
Archivo de imagen de disco de Rembo (solo lectura)
Sistema de archivos virtual Rembo
Interfaz de usuario Rembo
Dispositivos Loopback
Ficheros de mapeado de memoria Rembo
Tabla 3-1. Tipos URL definidos en Rembo
•
•
Dispositivo raíz : identifica el dispositivo, máquina o dominio en el cual está
almacenado el recurso.
Pathname : es la localización actual del fichero en el dispositivo raíz especificado
anteriormente.
3.2.- Protocolos de red
Se usan varios protocolos de red para la comunicación entre el cliente y el servidor Rembo :
Prácticas de Empresa 2001/02 1er Turno
Página 44
Manual de Administración del Cliente
NETfs
UDP Protocolo de ficheros
Unicast
MCAST
UDP
Protocolo
para
transferencia
de
ficheros
Multicast
FAST
UDP
Protocolo
para
transferencia
de
ficheros
Unicast
Tabla 3-2. Protocolos de red usados por Rembo
Se usa para los ficheros
net:
Se usa para bajar los
ficheros cache:
Se usa para enviar los
ficheros cache:
3.2.1.- Protocolo NETfs
El protocolo NETfs se usa para todas las operaciones de ficheros realizadas por el cliente en
el servidor. Tales como borrar un fichero, renombrarlo, crear un directorio, buscar un fichero...
También se usa para transferencias entre servidor y cliente (download) y entre cliente y
servidor (upload) cuando el path del fichero comienza por net:
La transferencia de ficheros podría ser menos eficiente que los otros dos protocolos debido a
su estructura de protocolo de petición-respuesta.
3.2.2.- Protocolo MCAST
Se trata de un protocolo multicast que se usa para transferencia de ficheros desde el servidor
a los clientes REMBO. Se usa por defecto cuando el path del fichero comienza por cache: o se
le puede llamar con la función Download.
Nota : Si no hay particiones locales, se usa NETfs en lugar de MCAST para bajar los ficheros
cache:.
Por defecto la transferencia no está encriptada pero puedes encriptarla con el parámetro del
servidor MCASTEncrypt (es ligeramente más lento).
No requiere ninguna sincronización entre las maquinas clientes, como ocurre con otros
protocolos multicast. Cuando un cliente quiere bajarse un fichero usando MCAST, le hace una
petición al servidor del fichero y o bien se une a una sesión multicast ya existente o bien crea
una nueva. Si el cliente se une a una sesión que ya existía, puede que no reciba todos los
paquetes del fichero porque sé unió a la sesión después de que algunos paquetes ya fueran
enviados. En ese caso los paquetes perdidos se pedirán automáticamente cuando el cliente se
convierta en la estación primaria para la sesión multicast, es decir, se convierta en el master de
esa sesión.
MCAST es un protocolo con muy buen rendimiento. Puede saturar fácilmente una red de
10Mb/s con trafico Multicast. Si quieres limitar el ancho de bando usado por MCAST para
prevenir la congestión de la red, puedes configurar la variable Settings/MCASTSpeed a un
valor distinto de cero para hacer ir más despacio las transferencias MCAST.
Si la variable Settings/UseMCAST esta puesta a false, REMBO usará NETfs en lugar de
MCAST para bajar los ficheros cache: a la partición caché local.
Nota : Por favor, lea la siguiente sección si necesitas transferir varios ficheros con MCAST.
Prácticas de Empresa 2001/02 1er Turno
Página 45
Manual de Administración del Cliente
3.2.3.- Protocolo Metacast
Mientras que sólo se transfiera un fichero a la vez, el protocolo MCAST en su forma actual es
el más eficiente para mandar dicho fichero a varios clientes. Sin embargo, si un grupo de
clientes pide varios ficheros en un corto periodo de tiempo, podrías observar varias
transferencias MCAST a la vez, porque una vez que un cliente ha bajado un fichero, pedirá el
siguiente, mientras que otros clientes pueden no haber completado la transferencia del primero.
La consecuencia de esto es que se realizan varias transferencias MCAST a la vez, lo que
llevaría una congestión de la red y a timeouts.
Metacast es un conjunto de scripts de Rembo-C que añaden el concepto de sincronización al
protocolo MCAST. Metacast trabaja como sigue:
•
•
•
•
Todos los clientes participantes tienen una lista de ficheros para bajarse y el mismo
nombre de sesión metacast.
Todos los clientes de una misma sesión, acuerdan el número de clientes que tienen
que estar presentes antes de que comience a transferirse el primer fichero, o un
timeout global desde que el primer cliente se una a la sesión y el primer fichero sea
transferido (sincronización al comienzo de la transferencia).
Una vez que el número requerido de clientes han alcanzado el punto de sincronización
o ha terminado el tiempo de espera, el servidor envía el primer fichero. Todos los
clientes reciben el fichero y esperan a que el último cliente lo termine de recibir
(sincronización al final de la transferencia).
Cuando todos los clientes han completado la transferencia, se programa el siguiente
fichero a transferir. Todos los clientes comienzan a descargarlo en el momento fijado
(transferencias programadas).
Estas restricciones de sincronización aseguran que sólo se está transfiriendo un fichero a la
vez en la red, incluso si cada cliente tiene que recibir varios ficheros. Gracias a esto se anula la
congestión de la red que se provocaba por múltiples transferencias MCAST.
Metacast se recomienda para la transferencia programada de muchos ficheros. Dado que
metacast requiere algunas acciones administrativas antes de comenzar una transferencia
(elegir el numero de clientes o el timeout global, comenzar los ordenadores al mismo tiempo)
es la mejor recomendación para transferencias de una única vez, tales como la inicialización de
cientos de ordenadores. Mcast es la opción preferida para las operaciones del día a día, donde
la cantidad de datos a transmitir es mínima y la sincronización manual no es posible.
3.2.4.- Protocolo FAST
El protocolo FAST es un protocolo unicast usado para las transferencias desde el cliente al
servidor Rembo (upload). Se usa por defecto cuando el path del fichero comienza por cache: ,
incluso si no hay una partición caché local.
FAST se ha diseñado para superar el funcionamiento limitado de NETfs cuando enviaba
grandes imágenes de disco al servidor. Esta basado en UDP, y usa timeouts adaptive y
ventana deslizante para obtener el mejor funcionamiento.
Por defecto no está encriptada la transferencia de ficheros, pero puedes hacerlo con el
parámetro del servidor FASTEncrypt.
FAST se ha diseñado para usar el máximo de ancho de banda disponible. En algunos casos
podría ser deseable limitar el ancho de banda usado por FAST, para ello basta configurar la
variable Settings/FASTSpeed a un valor distinto de cero.
Prácticas de Empresa 2001/02 1er Turno
Página 46
Manual de Administración del Cliente
3.3.- Uso de variables en REMBO
3.3.1.- Introducción
Las variables de Rembo-C necesitan ser declaradas, pero pueden hacerse en cualquier parte
del programa. Hay varios tipos de variables en Rembo:
•
•
•
•
Variables incorporadas (built-in): Estas variables existen siempre. Obtienen un valor
por defecto al arrancar REMBO.
Variables globales: se crean en scripts de Rembo-C. Son accesibles desde cualquier
parte. Cuando se crea una nueva función Rembo, su contenido se almacena en una
variable global del mismo nombre de la función. A menos que la exportes como una
variable persistente, las variables globales se borran cuando REMBO arranca el
sistema operativo o reinicia.
Variables locales: Se crean dentro de funciones, o de forma más general, dentro de
un bloque de código. Las variables locales son accesibles solo en el ámbito donde se
crean.
Variables persistentes : es un estado que se le añade al contenido de una variable
incorporada, global o local. Si el contenido de una variable se hace persistente con la
función Export, la variable será automáticamente recreada en el próximo arranque
durante la inicialización de REMBO.
Estas variables pueden ser de tipo simple(escalar) o complejo, Se soportan los siguientes
tipos:
•
•
•
•
•
int varname: valor entero de 32 bits con signo
bool varname: booleano (valores válidos: true o false);
str varname: cadena Rembo. Se pueden concatenar con el operador + y se puede
acceder a caracteres individuales usando la cadena como un array.
var varname: variable compleja Rembo, Este tipo de variable almacena una referencia
a una variable compleja, como un array, una estructura, buffer...
xxx varname[]: un array de elementos del tipo xxx.
3.3.2.- Variables incorporadas (built-in)
Para saber más de las variables incorporadas ver la versión en inglés del manual.
3.3.3.- Variables persistentes
Cuando creamos una variable en uno de nuestros scripts, la variable sólo existe durante la
sesión actual, ya que se almacena en la memoria del ordenador local. Cuando reiniciamos la
máquina y cargamos REMBO de nuevo perdemos el contenido de la variable.
Las variables persistentes son iguales que las variables normales, salvo que persisten
aunque se reinicie el ordenador. Una vez que una variable se declara como persistente
mantiene su valor durante la sesión actual y todas las siguientes. Esto es posible porque se
almacenan en el servidor y no en la memoria del ordenador local.
Cuando REMBO se inicia intenta cargar y ejecutar un fichero denominado autoload que se
encuentra en el servidor.
Prácticas de Empresa 2001/02 1er Turno
Página 47
Manual de Administración del Cliente
3.4.- Creación de imágenes de disco y restauración
La creación / restauración de imágenes de disco es una característica fundamental de
REMBO. Permite la clonación de sistemas operativos de una forma muy eficiente. A la hora de
escribir este manual REMBO es capaz de clonar los siguientes sistemas operativos:
•
•
•
•
MS-DOS.
Windows 95 / 98.
Windows NT4 / 2000.
Linux.
3.4.1.- Más sobre la clonación
La clonación es el proceso de duplicar e instalar un sistema operativo desde un ordenador de
referencia a uno o más ordenadores destino. Esto se hace haciendo un backup de todos los
datos almacenados en las particiones del ordenador de referencia y restaurando esos datos en
los ordenadores destino.
En este documento a los datos extraídos del ordenador de referencia lo llamamos imagen de
disco. Las imágenes de disco se almacenan normalmente en un fichero en el servidor, así
puede ser restaurado en los ordenadores destino sin necesidad de que el ordenador de
referencia esté encendido.
Hay dos métodos conocidos para la clonación de particiones de disco, clonación basada en
sectores (sector-based) o clonación basada en estructura (structure-based). La clonación
basada en sectores puedes ser dividida en otras dos categorías: blind analysis o allocationaware analysis. REMBO usa el método de clonación basado en estructura.
3.4.1.1.- Clonación basada en sectores
Este es el método más simple de clonación. Se hace un backup de todos los sectores del
disco y luego se almacenan en el ordenador destino. La herramienta de clonación no conoce la
estructura del sistema de fichero. Este tipo de método tiene la ventaja de soportar cualquier tipo
de sistema operativo. Como primera desventaja hay que señalar que la partición destino tiene
que tener el mismo tamaño que la partición origen. La segunda desventaja es que también se
clona el espacio libre por lo que las imágenes tienen un tamaño muy grande.
3.4.1.2.- Clonación basada en estructura
La clonación basada en estructura es lo opuesto a la clonación basada en sectores, porque
requiere un amplio conocimiento del sistema de fichero que está instalado en el ordenador de
referencia y la capacidad de reconstruir un sistema de fichero completo en el ordenador
destino.
El método de clonación basado en estructura trabaja con ficheros y directorios más que con
sectores, como una utilidad de backup/restore. Las ventajas que ofrece este método son :
•
•
Es más flexible que la clonación basada en sectores. La herramienta puede seleccionar
qué ficheros salvar o restaurar ( o cuales no).
Puede restaurar ficheros en un sistema de ficheros existente, sin tener que borrar los
ficheros que ya existen.
Prácticas de Empresa 2001/02 1er Turno
Página 48
Manual de Administración del Cliente
•
•
Las imágenes de disco se pueden editar para borrar ficheros o directorios que no se
quieran en el proceso de restauración.
Puede sincronizar más que clonar : los ficheros ya instalados en el ordenador destino
que sean idénticos al de referencia, no se copian.
3.4.2.- Crear una imagen de disco
El primer paso del proceso de clonación es crear una imagen de una de las particiones del
disco del ordenador de referencia. Esta imagen se usará entonces para clonar este ordenador
de referencia a otro ordenadores.
La función implicada en el proceso de creación de la imagen de disco es BuildDiskImage.
Los primeros dos parámetros de BuildDiskImage se usan para especificar la partición del
disco duro a copiar, mientras que el tercer parámetro es el nombre del fichero que usará
REMBO para almacenar la imagen de disco.
Nota : El nombre del fichero de la imagen de disco debe empezar con cache: o net: porque el
proceso de creación del disco de imagen tiene una fase que se lleva a cabo en el servidor. Si
quieres almacenar la imagen en otro lugar, primero debes crearla en el servidor de REMBO, y
después copiarla en donde quieras.
Ejemplo : Para crear una imagen de la primera partición almacenada en el primer disco duro,
y guardar el resultado en el fichero win98 en el servidor local, teclea:
BuildDiskImage(0,1,”cache://global/win98”);
Una vez creada la imagen, puedes bajártela a la partición caché local y mirar su contenido
con la siguiente secuencia de comandos:
OpenArchive(“testarch”,”cache://global/win98”);
FileMan(“arch://testarch/”);
Usa CloseArchive para cerrar el archivo abierto y liberar recursos del sistema.
Nota : Si el tercer parámetro de la función BuildDiskImage es un fichero de disco existente,
REMBO actualizará esta imagen con el nuevo contenido de la partición a la que se hace
referencia en lugar de copiar la partición de forma íntegra. Esto es útil si sólo añades unos
pocos ficheros a tu partición de referencia y te gustaría actualizar la imagen de disco para que
reflejara los cambios. Sin embargo, si quieres crear una imagen de disco nueva, entonces
debes borrarla antes de crearla de nuevo.
3.4.3.- Cómo restaurar una imagen de disco
La imagen de disco creada con REMBO puede ser restaurada posteriormente a uno o varios
clientes con la función RestoreDiskImage. Esta función toma tres parámetros: el disco duro y
el numero de partición a restaurar y el nombre del fichero que contiene la imagen de disco que
va a ser restaurada.
A continuación se muestran algunas consideraciones que hay que tener en cuenta sobre la
restauración de discos:
•
Cree particiones antes de restaurar la imagen de disco. Utilice un tipo de partición que
sea compatible con los datos almacenados en la imagen de disco.
Prácticas de Empresa 2001/02 1er Turno
Página 49
Manual de Administración del Cliente
•
•
•
Configurar siempre particiones caché en los ordenadores destino y utilizar la referencia
URL cache para especificar el nombre del fichero que contiene la imagen de disco.
Esto mejorará enormemente las prestaciones.
Puedes configurar una partición caché dejando espacio de disco no particionado al final
de tu primer disco duro. REMBO detectará automáticamente este espacio no
particionado y lo usará para cachear los ficheros de red accedidos con la especificación
URL cache:.
Si la partición destino no está vacía, puedes usar la función HDClean para limpiar la
partición antes de restaurar los ficheros en ella. Si intentas restaurar una imagen de
disco en una partición que contiene datos, REMBO cambiará automáticamente al modo
sincronización e intentará restaurar sólo los ficheros modificados. Si estas seguro de
querer machacar todos los datos de la partición destino, use HDClean para hacerlo
más rápido.
Ejemplo : este ejemplo muestra una secuencia de comandos REMBO necesarios para
preparar una partición destino y restaurar una imagen de disco creada con BuildDiskImage.
En este ejemplo, la imagen se restaurará en la primera partición del primer disco duro. El
tamaño del disco duro es de 2 Gb, y se quiere mantener 500 Mb para la partición caché :
•
Primero creamos la partición con la función SetPrimaryPartitions. Queremos 1.5 Gb
para una partición FAT16 :
SetPrimaryPartitions(0,”FAT16:1500000”);
Observe que la partición caché no se especifica ya que esta es un espacio no
particionado al final del disco.
•
Finalmente, restauramos la imagen de disco con la función RestoreDiskImage :
RestoreDiskImage(0,1,”cache://global/win98”);
Observe que esta función realiza un formateo rápido de la partición antes de restaurar
la imagen.
•
En resumen:
SetPrimaryPartitions(0,”FAT16:1500000”);
RestoreDiskImage(0,1,”cache://global/win98”);
/* Para arrancar la imagen de disco resultante */
HDBoot(0,1);
•
Para comprobar que todo se ha escrito de forma adecuada, puedes añadir un
administrador de ficheros en la partición destino escribiendo: FileMan(“disk://0:1/”); o
puedes arrancar la partición recientemente creada con HDBoot(0,1);
.
3.4.4.- Una restauración inteligente: Sincronización
La mayoría de las técnicas de clonación disponibles hoy se usan para instalar un nuevo
sistema operativo en maquinas cliente vacías. REMBO va un paso más allá con su modo
Sincronización, donde la clonación de disco no se limita más a la utilización de SO.
Prácticas de Empresa 2001/02 1er Turno
Página 50
Manual de Administración del Cliente
3.4.4.1.- Sincronización: cómo trabaja
En lugar de una realizar una restauración ciega de la imagen de disco, destruyendo todos los
datos previamente almacenados en la partición destino, Rembo es capaz de restaurar los
ficheros selectivamente basándose en varias reglas:
•
•
•
En modo por defecto, el proceso de sincronización restaurará sólo los ficheros en los
que el tamaño, la fecha o los atributos del fichero hayan cambiado. Esto es similar a
una herramienta estándar de backup/restore.
En modo seguro, el proceso de sincronización restaurará todos los ficheros cuyo
contenido haya cambiado.
En modo compatible, el proceso de sincronización restaurará todos los ficheros,
emulando a una herramienta estándar de clonación.
Además, puede trabajar en uno de los siguientes tres modos a la hora de decidir qué hacer
con los ficheros nuevos (ficheros que están en la imagen pero no en la partición destino) y con
los ficheros antiguos (ficheros que están en la partición destino pero que no están en la
imagen):
•
•
•
En modo comparación : el proceso de sincronización no añadirá nuevos ficheros a la
partición destino ni borraran ningún fichero de ella. REMBO sólo actualizará los
ficheros que estén presentes tanto en la partición destino como en la imagen.
En modo añadir (add mode) : se añadirán los nuevos ficheros a la partición pero no se
borrarán los ficheros antiguos. Este modo es muy útil para estaciones de trabajo.
En modo completo (full mode): se añaden los ficheros nuevos a la partición destino y
se borran los ficheros antiguos. La partición destino es una copia exacta de la imagen
al final del proceso de restauración. Este es el modo por defecto.
3.4.4.2.- Aplicaciones del metodo de Sincronización
Aquí hay una lista de entornos dónde la sincronización podría ser más útil que una simple
herramienta de clonación:
•
•
•
Escuelas y Universidades
Ciber-Cafés
Grandes compañías
3.4.4.3.- Sintáxis y uso del método de Sincronización
La sintáxis completa de la función Synchronize se puede encontrar en la página del manual
de Synchronize.
Nota : Observe que BuildDiskImage y RestoreDiskImage son alias de Synchronize :
BuildDiskImage(0,1,”cache://global/test”);
es equivalente a
Synchronize (“disk://0:1/”,”cache://global/test”,””);
y
RestoreDiskImage(0,1,”cache://global/test”);
es equivalente a
HDClean(0,1);
Synchronize(“cache://global/test”,”disk://0:1/”,”b”);
Prácticas de Empresa 2001/02 1er Turno
Página 51
Manual de Administración del Cliente
3.5.- Conceptos avanzados de clonación
3.5.1.- Filtrando ficheros con Imágenes Virtuales
En algunas circunstancias se podría requerir hacer una copia sólo de un subconjunto de la
partición de referencia, o filtrar algunos ficheros que no se quieren, como el fichero de
paginación de memoria (Windows 9x y Windows NT).
Nota : las imágenes virtuales no son soportadas en Rembo Classic Edition. Deberías usar en
su lugar RemoveFile y Synchronize en modo “+”
La imagen virtual te puede ayudar en esta tarea. Una imagen virtual es una copia de la
estructura de directorios (sólo ficheros y directorios) de un sistema de ficheros existente. Esta
imagen virtual puede ser modificada añadiéndole otro sistema de ficheros (fusión) o borrando
ficheros o directorios.
Si quieres borrar sólo unos pocos ficheros de tu partición de referencia antes de crear una
imagen, podrías usar RemoveFile, y así no tener que configurar una imagen virtual. La
diferencia entre borrar ficheros con una imagen virtual o hacerlo con RemoveFile es que la
imagen virtual no modifica la partición de referencia mientras que RemoveFile borra
físicamente el fichero de la partición.
El proceso de creación de una imagen de disco apartir de una imagen virtual es muy simple:
•
•
•
•
•
Crear una imagen virtual de la partición de referencia.
Opcionalmente, añadir otras particiones como un subdirectorio de la imagen virtual.
Borrar los ficheros y directorios no deseados, tales como ficheros de paginación o
temporales.
Usar Synchronize para construir una imagen de disco a partir de la imagen virtual.
Cerrar la imagen virtual para liberar recursos del sistema.
Veamos ahora cada uno de estos pasos.
1. Crear la imagen virtual: CreateVirtualImage.
El primer parámetro de la función es el nombre de la imagen virtual. El segundo
parámetro es el camino desde el que copiar la estructura de directorios. Puede ser el
directorio raíz de una partición o un subdirectorio si sólo quieres guardar parte de la
partición de referencia.
CreateVirtualImage(“testimage”,”disk://0:1/”);
FileMan(“link://testimage/”);
2. Añadir ficheros o directorios a una imagen virtual: LinkTree.
LinkTree(“link://testimage/dir3”, “net//group/testf”);
3. Borrar ficheros o directorios de una imagen virtual: UnLinkTree.
Por ejemplo, para borrar el fichero pagefile.sys de la raíz de tu imagen virtual usamos
lo siguiente :
UnLinkTree(“link://testimage/pagefile.sys”);
4. Construir una imagen de disco a partir de una imagen virtual: Synchronize.
Utilizar el camino de la imagen virtual como primer parámetro. Por ejemplo, para crear
la imagen de disco de la imagen virtual previamente creada :
Prácticas de Empresa 2001/02 1er Turno
Página 52
Manual de Administración del Cliente
Synchronize(“link://testimage/”,”cache://global/ntimage”,””);
Ejemplo : a continuación mostramos una secuencia típica de comandos usados para crear
una imagen virtual desde una partición de referencia, usando imágenes virtuales para borrar
ficheros:
CreateVirtualImage(“winimage”,”disk://0:1/);
UnLinkTree(“link://winimage/windows/win386.swp”);
Synchronize(“link://winimage/”,”cache://global/winimage”,””);
FreeVirtualImage(“winimage”);
3.5.2.- Imágenes incrementales
Una imagen incremental es la diferencia entre dos sistemas de ficheros, en cuanto a
ficheros/directorios añadidos y ficheros/directorios borrados. Esta diferencia se puede
almacenar en una imagen de disco, creando una imagen de disco incremental.
Las imágenes incrementales son útiles para crear paquetes de instalación software,
independientemente del hardware instalado. Por ejemplo podrías crear una imagen de un
Windows 98 recién instalado, y llamarlo win98base. Entonces, podrías crear una imagen
incremental de la misma partición de referencia después de haber instalado MS Office en el
ordenador. La imagen incremental sólo contendrá los ficheros de Ms Office y estarán
separados de la imagen base. Si haces esto para otro software, tendrás una librería software
preparada para instalaciones. Ya que estas imágenes incrementales son independientes de la
imagen base, podría instalar MS Office en otra imagen base (es decir, win98base2, es una
imagen base para un hardware diferente) sin tener que recrear una nueva imagen.
3.5.2.1- Imágenes incrementales básicas
Las imágenes incrementales básicas son la forma más simple de hacer una imagen
incremental. La diferencia entre el estado inicial y el nuevo estado, incluyendo ficheros de
configuración, se almacenan en un único fichero. En la restauración, los ficheros de
configuración se reemplazarán por la versión almacenada en la imagen incremental
te método trabaja bien si estas fusionando una única imagen incremental con la imagen base
a la vez. Si quieres fusionarla con más de una imagen incremental debes usar imágenes
incrementales avanzadas.
3.5.2.2.- Imágenes incrementales avanzadas
Si quieres fusionar varias imágenes incrementales con una imagen base, debes manejar los
cambios de los ficheros de configuración de forma separada. Dependiendo del SO que estés
clonando tendrás que ejecutar pasos adicionales a la creación de imágenes incrementales.
•
•
•
En Windows 95/98 : los ficheros de registros se sacan de las imágenes incrementales,
y deben ser tratados de forma separada con un fichero patch de registro (.reg) para
cada imagen incremental.
En Windows NT : los ficheros de registros deben sacarse de las imágenes
incrementales y tratados individualmente con imágenes ficheros de registros
individuales para cada imagen incremental.
En Linux : los ficheros de registros que afecten a mas de una imagen incremental
deberán ser sacados fuera y tratados de forma separada con ficheros de texto patch
diferenciales.
Prácticas de Empresa 2001/02 1er Turno
Página 53
Manual de Administración del Cliente
REMBO proporciona poderosas herramientas para la fácil creación de imágenes
incrementales limpias, específicamente para Windows NT/2000 para el que la operación es la
más complicada. Las tres operaciones básicas para manejar esta operación son TextDiff,
MakeDiffFromText y ApplyDiff. Ver las paginas del manual de estas funciones para detalles
de su uso.
3.5.2.3.- Cómo crear una imagen incremental
La función base para crear imágenes incrementales es Synchronize. Los dos primeros
parámetros son la fuente y el destino de la comparación, y el tercer parámetro se usa para
decirle a Rembo dónde guardar la diferencia (la imagen incremental).
Ejemplo : para crear una imagen incremental hecha de la diferencia entre tu partición de
referencia y tu imagen de disco base, teclea:
Synchronize(“disk://0:1/”,”cache://global/win98base”,
”>cache://global/msoffice”);
En la mayoría de los casos, necesitarás filtrar registros fuera de la comparación. Para hacer
esto, debes borrar los registros tanto en la partición de referencia como en la imagen base, de
tal forma que los registros no sean ni un fichero nuevo ni un fichero borrado. Las imágenes
virtuales se deben usar para conseguir esto:
// 1. Borrar loas registros backups
de la partición
RemoveFile(“disk://0:1/windows/system.da0”);
RemoveFile(disk://0:1/windows/user.da0”);
//2. Filtrar los registros con una imagen virtual
CreateVirtualImage(“”source”,”disk://0:1/”);
UnLinkTree(“link://source/windows/system.dat”);
UnLinkTree(“link://source/windows/user.dat”);
//3. Filtrar registros en la imagen de disco
OpenArchive(“destarch”,”cache://global/win98base”);
CreateVirtualImage(“dest”,”arch://destarch/”);
UnLinkTree(“link://dest/windows/system.dat”);
UnLinkTree(“link://dest/windows/user.dat”);
//4. Comparar imágenes virtuales para crear una imagen incremental
Synchronize(“link://source/”,”link://dest/”,”>cache://global/msoffice”);
//5. Liberar recursos
FreeVirtualImage(“dest”);
FreeVirtualImage(“source”);
CloseArchive(”destarch”);
Si utilizas TextDiff y MakeDiffFromText en lugar de Synchronize para crear tus imágenes
incrementales, los cambios en la imagen virtual las haces tú implícitamente con estas
funciones. Además, estas funciones te permite seleccionar específicamente que ficheros deben
o no ser parte de la imagen incremental. Es por tanto altamente recomendable usar estas
funciones para la creación de imágenes incrementales, en lugar de crearlas directamente. Esto
es especialmente cierto para Windows NT/2000.
Prácticas de Empresa 2001/02 1er Turno
Página 54
Manual de Administración del Cliente
3.5.3.- Fusión de imágenes usando imágenes virtuales
Si creaste imágenes incrementales como se describe en la sección 3.5.2., probablemente
tengas que restaurar varias imágenes en una única partición: una imagen base y una imagen
para cada aplicación seleccionada por el usuario o por el archivo profile del ordenador. Cuando
restauras varias imágenes en una única partición tienes dos opciones:
•
•
Ejecutar la función RestoreDiskImage para cada imagen.
Usar imágenes virtuales para fusionar las imágenes antes de la restauración.
Nosotros recomendamos usar la segunda alternativa, porque ofrece mejores prestaciones que
la primera
3.5.3.1.- ¿Cómo fusionar las imágenes?
Primero necesitas crear una imagen virtual con tu imagen base, y después añadir las otras
imágenes con la función LinkTree. El siguiente ejemplo muestra una secuencia típica de
comandos para una restauración de varias imágenes:
Ejemplo : Restauración de varias imágenes.
En este ejemplo vamos a restaurar una imagen base win98base y dos imágenes
incrementales msoffice y netscape en una única partición, usando imágenes virtuales.
//1. Crear la imagen virtual
OpenArchive(“base”,”cache://global/win98base”);
CreateVirtualImage(“virtual”,”arch://base/);
//2. Añadir la primera imagen incremental
OpenArchive(“incr1”,”cache://global/msoffice/”);
LinkTree(“link://virtual/”,”arch://incr1/”);
//3. Añadir la segunda imagen incremental
OpenArchive(“incr2”,”cache://global/netscape/”);
LinkTree(“link://virtual/”,”arch://incr2/”);
//4. Restaurar a la partición destino
Synchronize(“link://virtual/”,”disk://0:1/”,”b”);
//5. Liberar recursos
FreeVirtualImage(“virtual”);
CloseArchive(“incr2”);
CloseArchive(“incr1”);
CloseArchive(“base”);
3.5.4.- Conversión del tipo de partición
Un archivo se suele restaurar en el mismo tipo de partición (FAT16, FAT32, NTFS) que en la
que fue creada. La partición donde se restaure no tiene por qué ser del mismo tamaño que la
original, basta que sea lo suficientemente grande para almacenar el contenido del archivo. Sin
embargo, cuando un sistema operativo puede almacenarse en varios tipos de partición, no está
claro el hecho de restaurarlo en un tipo diferente al original..
Prácticas de Empresa 2001/02 1er Turno
Página 55
Manual de Administración del Cliente
Los dos tipos de conversión de particiones que podrías querer hacer cuando restauras un
archivo son:
•
•
Windows 95/98: en FAT16 o FAT32
Windows 2000/NT: en FAT16 (BIGDOS) o NTFS
Si intentas restaurar un archivo en una partición de un tipo diferente a la original, recibirás un
aviso en la consola advirtiéndote que el sector de arranque no es compatible y se saltó. Esto
significa que la partición tendrá todos los ficheros correctamente restaurados pero no tiene un
sector válido de arranque y no será “botable”.
Para conseguir restaurar un archivo que sea botable, debes proceder de la siguiente manera:
•
•
•
Limpiar la partición destino para asegurarte de tener un sector de arranque con los
parámetros de tamaño correctos.
Restaurar un sector de arranque de cualquier archivo que tengas que coincida con el
tipo de la partición destino.
Restaurar todos los ficheros que quieres tener en la partición.
Ejemplo : cómo restaurar una imagen en una partición de otro tipo.
En la práctica, esto se puede hacer con un script como el siguiente. Aquí hacemos la
restauración de una imagen en FAT32 a una partición BIGDOS. Para hacerlo, tienes
que tener en algún lugar un archivo de imagen BIGDOS (con cualquier cosa, no
importa), para ser capaz de obtener su sector de arranque.
// 1. Configurar el tipo de partición que se desee
SetPrimaryPartitions(0,”BIGDOS:1000000”);
// 2. Limpiarla.
HDClean(0,1);
// 3.Restaurar el sector de arranque apropiado de cualquier imagen
// BIGDOS. La restauración en modo (b=) asegura que no se copiara ningún
// fichero.
Synchronize(“cache://global/hdimages/win9x/bigdos.img”,
”disk://0:1”,”b=”);
//4. Restaurar todos los ficheros de la imagen FAT32
Synchronize(“cache://global/hdimages/win9x/fat32.img”,”disk://0:1”,””);
3.6.- Iniciando REMBO sin conexión a la red
Hay cuatro formas de arrancar REMBO sin conexión a red:
•
•
•
•
Modo Off-line (Desconectado).
Arrancar desde un CD de autoarranque.
Arrancar desde un disquete.
Mediante activación PXE.
3.6.1.- Modo desconectado
Si accedemos a todos los archivos de la red mediante URLs del tipo: cache:// en vez de net://
REMBO podrá acceder a los mismos directamente de la caché sin tener que recurrir a la red.
Prácticas de Empresa 2001/02 1er Turno
Página 56
Manual de Administración del Cliente
3.6.1.1.- Configurando el modo desconectado
Antes que nada debemos asegurarnos que la BIOS permite arrancar del disco duro si el
arranque desde la red falla. A continuación añadimos en el cliente una llamada a la función
SetOfflineMode, esto escribirá un pequeño gestor de arranque en el MBR del disco duro,
esta línea estará antes de cualquier comando que modifique las particiones, no se debe usar
tampoco la llamada a HDClean si no queremos echar a perder todo el trabajo hecho por
SetOfflineMode.
A continuación arrancamos la máquina de la forma habitual y restauramos las imágenes de
los distintos sistemas operativos. Si ahora desconectamos el cable de red veremos como es
posible arrancar los sistemas operativos sin conexión a la red.
Podemos generar un script especial para este tipo de arranque y guardarlo como disk://0:1/autoload, esto hará que se ejecute este script en vez de la página rembo.shtml.
Si no queremos escribir en el MBR podemos escribir el script en el sector de arranque de una
partición y marcar esta partición como de arranque.
3.6.1.2.- ¿Cómo de seguro es el modo desconectado?
Se recomienda restaurar un sistema siempre desde la red, ya que los datos en el disco local
pueden estar corruptos y están sujetos a mas peligros que el propio disco del servidor.
Los algoritmos de encriptación utilizados para proteger la partición caché aseguran que los
datos contenidos en la misma no se volverán corruptos. Sin embargo, no protegen contra el
uso malintencionado y los intentos de desestabilizar el sistema.
Una alternativa al modo desconectado es la activación PXE , la cual veremos más adelante.
3.6.1.3.- REMBO como gestor de arranque
Según todo lo visto REMBO puede ser usado como un efectivo y agradable gestor de
arranque, siendo una buena alternativa a LILO para aquellos usuarios de Linux.
3.6.1.4.- Imágenes del modo desconectado
Es recomendable guardar versiones de las imágenes de los sistemas operativos sin función
de red , así será posible arrancar la máquina y trabajar con ella sin que nos esté dando errores
constantemente de que no es capaz de conectar con el servidor principal.
3.6.2.- Arrancar desde un CD de autoarranque
Es deseable contar con copias de seguridad para restaurar un sistema en caso de un
desastre. Para ello REMBO es capaz de generar un CD de autoarranque capaz de restaurar el
sistema y arrancar sin conexión a la red.
3.6.2.1 Creando un CD de autoarranque
Crear un CD autoarrancable es tan sencillo como configurar un cliente : primero creamos las
imágenes y, a continuación, activamos el modo desconectado como hemos visto en la sección
Prácticas de Empresa 2001/02 1er Turno
Página 57
Manual de Administración del Cliente
3.6.1.1, después de probar todas las configuraciones y ver que el sistema puede arrancar bien
sin red. Es recomendable crear un script autoload que determinará el comportamiento al
arrancar.
Usaremos a continuación la función CreateRemboCDRom para crear un CD ISO
autoarrancable con todas las imágenes y los scripts necesarios para arrancar.
Una vez hecho esto podremos copiar esta imagen ISO a un CD y utilizarlo para arrancar
cualquier máquina de la red.
3.6.3 Arrancando REMBO desde un disquete
Es posible generar un disquete de inicio para REMBO. Lógicamente en un disquete no caben
imágenes grandes, por eso debemos asegurarnos que las imágenes que estén en la partición
de caché quepan en un disquete o el proceso no funcionará.
Para crear el disquete utilizaremos la función CreateRemboFloppy. Recomendamos guardar
esta imagen en la dirección cache://global/fdmages para poder manejarla cómodamente con
los asistentes.
Podemos restaurar esta imagen utilizando los asistentes o bien con la función
RestoreFloppyImage. Una vez hecho esto podremos arrancar REMBO y acceder a los archivos
guardados en la imagen de disquete a través de la dirección cache://global.
3.6.4 Activación PXE
REMBO es capaz de utilizar un adaptador de red PXE incluso si el proceso de arranque no se
realizó como tal, este proceso se conoce como activación PXE.
La activación PXE añade otro nivel de seguridad a las máquinas públicas de la red, de tal
forma que incluso si un usuario fue capaz de redirigir el arranque al disco duro REMBO seguirá
arrancando y restaurando desde el servidor.
Esta característica permite arrancar una configuración REMBO en una red sin servidor
REMBO e incluso buscar en la red posibles servidores REMBO.
La activación consta de dos pasos:
•
•
Primero cargamos la ROM PXE en la zona de memoria baja utilizando la función
LoadUNDI.
Por último los parámetros IP son configurados mediante la función SetIPInfo.
Los parámetros IP pueden ser dados mediante un servidor DHCP o de forma directa. La
dirección del servidor REMBO primario estará especificada en la función SetIPInfo.
Estas llamadas se hacen desde el archivo autoload de la configuración desconectada. Así un
disquete de arranque REMBO podría conectarse automáticamente a un servidor REMBO
predefinido.
Si es necesario podemos detectar si una máquina esta corriendo en modo desconectado o no
comprobando si tiene dirección IP de la siguiente forma:
If ((int)NetInfo.IPAddress ¡= 0 ) {
//en linea
}
Prácticas de Empresa 2001/02 1er Turno
Página 58
Manual de Administración del Cliente
3.7.- Uso de canales TCP para acceder a recursos
remotos
Es posible utilizar canales TCP para comunicar entre si distintas máquinas que corren
REMBO determinando el nombre de Host y el puerto de cada uno. Gracias a esta característica
podemos implementar aplicaciones bastante interesantes :
•
•
•
•
Conectar con un servidor SMTP para mandar un correo al administrador e informar si
algo ha ido mal.
Conectar con un servidor de base de datos.
Acceder a un servidor HTTP para obtener información de Internet.
Acceder a suites de control o interactuar con métodos de autentificación.
3.7.1. Mandando correo electrónico con REMBO
demos utilizar la función SendMail para mandar correo a un administrador, para ello debemos
crear un canal TCP en la configuración del servidor.
El identificador para el canal será sendmail y el parámetro para RemotePort será 25. El
parámetro para RemoteHost será la IP del servidor SMTP.
Después de configurar estos parámetros debemos reiniciar el servidor REMBO y en el cliente
debemos ejecutar join(Exec(“cache://global/plugins/sendmail.rbx”)); para acceder a SendMail,.
A partir de aquí ya podremos mandar mensajes con REMBO.
3.7.2. Acceso a bases de datos con REMBO
REMBO soporta ODBC, lo que le permite conectar con multitud de servidores de bases de
datos.
En un servidor Windows NT tendremos que instalar los drivers ODBC necesarios para
conectar con nuestra base de datos. En un sistema Solaris/Linux será necesario instalar el
paquete UnixODBC que le permitirá hacer lo mismo con multitud de bases de datos (incluidas
MySQL y PostgreSQL).
El proceso es el siguiente:
•
•
•
Abrimos un canal TCP que dirige las consultas del cliente a un enlace ODBC instalado
en la máquina que corre como servidor REMBO. Seguidamente este la manda al
manejador ODBC y este finalmente manda la consulta a la base de datos. La respuesta
sigue el mismo camino de vuelta hasta el cliente.
El enlace ODBC está en el directorio ODBC de la distribución empresarial, para
instalarlo como un servicio WindowsNT será necesario ejecutar dbgw –i; para quitarlo
dbgw –u.
El enlace entre TCP y la puerta de enlace solo contesta peticiones de localhost
(127.0.0.1). Esto se hace para prevenir que otras máquinas distintas del servidor
REMBO puedan acceder a la base de datos a través del enlace. (RemoteHost
127.0.0.1 y RemotePort 2020).
Para configurar esta característica hacemos lo siguiente:
•
•
Tener un servidor de base de datos listo.
Configurar en el servidor REMBO los drivers ODBC necesarios para acceder a la base
de datos.
Prácticas de Empresa 2001/02 1er Turno
Página 59
Manual de Administración del Cliente
•
•
Instalar el enlace ODBC : en WindowsNT ejecutar dbgw –inst ; en Unix ./dbgw.
Configurar el canal TCP en el servidor REMBO. (RemoteHost 127.0.0.1 y RemotePort
2020).
Para usar bases de datos en los scripts ejecutar lo siguiente :
join(Exec(“cache://global/plugins/sql.rbx”));
Las funciones de acceso a bases de datos son:
•
•
•
•
SQLOpen : Abre la sesión SQL.
SQLQuery : Ejecuta una consulta SQL.
SQLClose : Cierra la sesión.
SQLQuickQuery : Abre la sesión , consulta y cierra en un único paso.
Prácticas de Empresa 2001/02 1er Turno
Página 60
Manual de Administración del Cliente
CAPÍTULO 4: INSTRUCCIONES ESPECÍFICAS PARA CADA S.O.
Este capítulo describe en detalles los procedimientos para clonar cada tipo de SO. Los
procedimientos difieren de uno a otro, no en el mecanismo de clonación en sí mismo, sino en la
reconfiguración automática post-clonación que se quiera usar.
4.1.- Clonando MS-DOS
4.1.1.- Clonando un sistema MS-DOS
Prepare un puesto de trabajo de referencia con una instalación típica en la primera partición
del disco duro. Asegúrese de no dejar archivos temporales en la partición de referencia.
Recomendamos que cree un fichero rembo.bat en el directorio raíz de su partición de
referencia y añada la línea call c:\rembo.bat en alguna parte del autoexec.bat. Esto hará
posible ajustar su imagen MS-DOS en tiempo de ejecución añadiendo comandos en el fichero
rembo.bat. En la partición de referencia, simplemente deje rembo.bat vacío.
Arranque el cliente con REMBO. Cree su imagen con BuildDiskImage como se describe en
la sección 3.4.2. Llame a la imagen cache://global/images/dosimage.
Para restaurar la imagen en el ordenador destino, use RestoreDiskImage como se describe
en la sección 3.4.3. No olvide crear una partición FAT válida en el ordenador destino antes de
ejecutar RestoreDiskImage.
4.1.2. Ajustando un sistema MS-DOS
Puede que necesite modificar ficheros de sistema en tiempo de ejecución, cuando la imagen
del disco haya sido restaurada en el ordenador destino. Dependiendo de sus necesidades,
necesitará modificar el autoexec.bat para añadir nuevos comandos o modificar un fichero de
sistema para reflejar la información que REMBO ha obtenido sobre su ordenador destino (p.e.
añadir variables de entorno conteniendo un nombre de usuario o una dirección IP).
Si creó un fichero rembo.bat durante la creación de la imagen de disco, entonces será capaz
de añadir comandos o variables de entorno modificando este fichero, ya que es llamado desde
el autoexec.bat. Para modificar su rembo.bat desde REMBO, cree un fichero plantilla en el
servidor y use el comando PatchFile para copiar la plantilla a disk://0:1/rembo.bat, con
sustitución de expresiones automática.
Ejemplo : Parcheo del archivo rembo.bat
Este ejemplo muestra el contenido de un fichero plantilla y el contenido de rembo.bat
después de copiar la plantilla sobre el fichero destino con PatchFile.
•
Contenido del fichero plantilla:
ECHO "Installing environment variables"
SET IPADDRESS={$NetInfo.IPAddress$}
SET HOSTID={$NetInfo.MACAddress$}
SET USERNAME={$AuthInfo.UserName$}
SET FULLNAME={$AuthInfo.FullName$}
SET DOMAIN=COMPANY
Prácticas de Empresa 2001/02 1er Turno
Página 61
Manual de Administración del Cliente
•
Contenido del fichero parcheado:
ECHO "Installing environment variables"
SET IPADDRESS=192.168.1.10
SET HOSTID=00 90 27 12 34 56
SET USERNAME=rembotest
SET FULLNAME=Rembo tester
SET DOMAIN=COMPANY
El comando usado para generar el archivo rembo.bat parcheado es :
PatchFile(NetFile("rembo.bat.tmpl"),"disk://0:1/rembo.bat");
Recomendamos que use la función NetFile para ajustar sus hosts. La función NetFile primero
comprueba si el fichero existe en el nivel net://host/, entonces intenta el nivel net://group/ y
finalmente usa net://global/ si el fichero no existe ni en el ámbito de host ni de grupo. El uso de
NetFile hace posible añadir comportamientos definidos para un grupo de hosts o un solo host
simplemente añadiendo la rembo.bat.ref en el lugar apropiado del servidor.
PatchFile puede también ser usado para modificar un fichero de sistema, por ejemplo un
fichero de configuración usada por su pila MS-DOS TCP/IP. Puede usar REMBO para insertar
la información de red apropiada (nombre de host, dirección IP, ...) en el fichero de
configuración. Vea la seccion 3.3 para una lista de variables disponibles.
4.1.3. Instalando clientes Lan Manager para UNDI
Los clientes LanMan son clientes Microsoft Network para MS-DOS. Ellos pueden ser usados
para acceder a servidores Windows NT desde MS-DOS.
LanMan usa un driver de red NDIS para acceder al hardware de red. Este driver is
normalmente entregado por el fabricante de la tarjeta de red. Recientemente, Intel ha
desarrollado un driver NDIS universal que hace uso del chip de arranque remoto PXE (PXE
bootrom) para proporcionar acceso de red a LanMan. Si usa este driver, su instalación LanMan
trabajará en todas las tarjetas de red PXE si arrancan a través de REMBO.
Lea la página http://www.rembo.com/rembo/resources.html para obtener enlaces a diferentes
ficheros necesarios para LanMan. También encontrará ejemplos de parches para ficheros de
configuración LanMan.
Para instalar clientes LanMan, siga estos simples pasos:
•
•
•
•
•
•
Descargue los tres discos LanMan y el driver Intel NDIS;
Cree una partición MS-DOS vacía pero arrancable e instale los tres discos LanMan en
esta partición;
Copie el driver Intel NDIS y cambie los ficheros de configuración LanMan para usar
este driver;
Haga una imagen de esta partición con REMBO;
Restaure la imagen y arranque con DeviceBoot(“disk://0:1”,false); en lugar de
HDBoot(0,1); para conservar el “PXE bootrom” cargado en memoria;
Compruebe que todo está funcionando correctamente;
Prácticas de Empresa 2001/02 1er Turno
Página 62
Manual de Administración del Cliente
4.2.- Clonando Windows 95/98
Esta sección describe cómo crear una imagen base para Windows 95/98, cómo crear
imágenes incrementales y como ajustar su ordenador destino después de la restauración (p.e.
cambiar el nombre de host).
La mayoría de las operaciones descritas en esta sección puede ser realizadas con los
asistentes. Esta sección muestra como llevar a cabo estas operaciones con scripts Rembo-C.
4.2.1.- Creando una imagen base Windows 9x
Esta primera sección describe como crear una imagen completa de disco duro Windows
95/98. Esta imagen es importante porque será la base para las imágenes incrementales, y
también su copia de seguridad de emergencia si su disco duro se corrompe.
Configure un cliente típico Windows 95/98, desde el principio, o arrancando desde el cliente
MS-DOS e instalando Windows sobre la red. Puede también usar una máquina con Windows
preinstalado. Para simplificar las instrucciones, asumiremos que ha instalado Windows en la
primera partición del disco duro.
Cree un fichero llamado rembo.bat en el directorio raíz, y añada la línea call c:\rembo.bat en
algún lugar del autoexec.bat. Esto hará posible ajustar el proceso de arranque en tiempo de
ejecución añadiendo comandos al fichero rembo.bat. En la partición de referencia, deje
rembo.bat vacío.
Ahora arranque REMBO, y ejecute FileMan(“disk://0:1”); para mostrar el contenido de su
partición Windows. Entonces, cierre el administrador de archivos y use el siguiente script para
crear la imagen base :
// 1. Crear una imagen virtual del disco
CreateVirtualImage("win9x","disk://0:1");
// 2. Eliminar el fichero de paginación de la imagen virtual
RemoveFile("link://win9x/windows/win386.swp");
// 3. Eliminar cualquier versión previa de un archivo
if(FileExists("cache://global/hdimages/win9x/baseimage.img"))
RemoveFile("cache://global/hdimages/win9x/baseimage.img");
// 4. Crear un archivo de la imagen virtual
Synchronize("link://win9x","cache://global/hdimages/win9x/baseimage.img"
,"");
// 5. Liberar los recursos
FreeVirtualImage("win9x");
El script anterior almacena el contenido de su disco duro en un fichero
cache://global/hdimages/win9x/baseimage.img en el servidor. Puede eliminar otros ficheros o
directorios (p.e. ficheros temporales) para limpiar ficheros inútiles de la imagen. Los ficheros o
directorios eliminados durante el paso 2 no son realmente eliminados del disco duro porque
usamos una imagen virtual (una imagen virtual es una copia de la estructura del disco usada
para editar directorios sin modificar el dispositivo subyacente).
Ahora tiene una copia de seguridad de su puesto de trabajo de referencia en el servidor. El
próximo paso es comprobar que la imagen es válida.
Prácticas de Empresa 2001/02 1er Turno
Página 63
Manual de Administración del Cliente
4.2.2.- Comprobando la imagen base del disco
Ahora debe verificar que la imagen base del disco funciona restaurando la imagen. Es
recomendable restaurar la imagen en un ordenador diferente del usado para crear la imagen de
referencia para prevenir la corrupción del puesto de trabajo de referencia si algo fue mal.
Arranque REMBO, configure las particiones con los asistentes (no olvide dejar algo de
espacio al final del disco para el caché de particiones local). Entonces restaure su imagen
Windows 9x con el siguiente comando:
RestoreDiskimage(0,1,”cache://global/hdimages/win9x/baseimage.img”);
Una vez la descarga y restauración se complete, ejecute FileMan(“disk://0:1”); para mostrar
los ficheros creados en su disco duro. Ejecute HDBoot(0,1); para arrancar en su partición
Windows 95/98.
En este punto, usted tiene una copia de seguridad completa de su ordenador de referencia en
caso de problemas durante los siguientes pasos de este tutorial. Puede volver en cualquier
momento a este estado inicial restaurando la imagen base de nuevo.
4.2.3.- Crear un script de restauración
Esta sección explica como automatizar el proceso de restauración con un script. Si está
ejecutando REMBO Professional o Enterprise, puede obtener resultados similares definiendo
acciones de arranque automatizadas usando los asistentes.
Puede usar el siguiente script para restaurar su imagen base en el puesto de trabajo. Este
script realiza las siguientes acciones :
•
•
•
•
Configura particiones a un estado compatible con la imagen.
Restaura la imagen base.
Calcula un nombre único para el equipo y crea un parche para el registro de Windows
que será aplicado antes de que Windows comience.
Arranque.
// 1. Crear una partición de 1GB FAT16 (o BIGDOS)
SetPrimaryPartitions(0,"BIGDOS:1000000");
// 2. Restaurar la imagen
RestoreDiskImage(0,1,"cache://global/hdimages/win9x/baseimage.img");
// 3a. El nombre de la máquina está formado por los últimos bytes de la
// dirección IP.
var ipa = StrParse(NetInfo.IPAddress,".");
str Hostname = "PC-"+ipa[2]+"-"+ipa[3];
// 3b. Crear un parche del registro para establecer el nombre de la
// máquina
CreateTextFile("disk://0:1/rembo.reg",
"REGEDIT4\n\n"
"[HKEY_LOCAL_MACHINE\\System\\CurrentControlSet"
"\\Services\\VxD\\VNETSUP]\n"
"\"ComputerName\"=\""+Hostname+"\"\n\n"
"[HKEY_LOCAL_MACHINE\\System\\CurrentControlSet"
"\\Services\\VxD\\MSTCP]\n"
"\"HostName\"=\""+Hostname+"\"\n\n"
"[HKEY_LOCAL_MACHINE\\System\\CurrentControlSet"
"\\control\\ComputerName\\ComputerName]\n"
"\"ComputerName\"=\""+Hostname+"\"\n");
Prácticas de Empresa 2001/02 1er Turno
Página 64
Manual de Administración del Cliente
// 3c. Añadir una llamada al regedit en nuestro fichero .bat
CreateTextFile("disk://0:1/rembo.bat",
"c:\\windows\\regedit"
" /L:c:\\windows\\system.dat"
" /R:c:\\windows\\user.dat"
" c:\\rembo.reg");
// 4. Arrancar desde el disco
HDBoot(0,1);
Para usar el script anterior, guárdelo en un archivo aparte, copie el fichero en el servidor y
escriba Exec(“net://global/scriptname”); (sustituya scriptname con el nombre de su script).
Para ejecutar el script automáticamente, cree una página HTML conteniendo un mensaje de
bienvenida y una sección <SCRIPT>, como la que hay en el fichero rembo.shtml. Añada la
llamada a la función Exec en la sección script de su página HTML, o simplemente copie y
pegue el contenido del script. Entonces, cambie el parámetro del servidor StartPage para sus
hosts de prueba al URL REMBO de página HTML que acaba de crear.
Puede ajustar el script a sus necesidades. Si quiere crear dos particiones, una para el sistema
y otra para los datos, simplemente añada una entrada BIGDOS:xxx en la cadena de
particiones, y no olvide hacer un formateo rápido a esta partición al menos una vez con
HDClean :
SetPrimaryPartitions(0,”BIGDOS:500000 BIGDOS:500000”);
HDClean(0,2);
…
Puede usar una variable persistente para determinar si es la primera vez que ejecuta este
script, y así ejecutar HDClean una sola vez.
Si quiere usar particiones FAT32 en lugar de FAT16, use entradas FAT32:xxx en la cadena de
particiones. Sin embargo, tenga cuidado de que FAT16 y FAT32 no usen el mismo sector de
arranque. Por consiguiente, si restaura una imagen FAT16 en una partición FAT32 (o
viceversa), el sector de arranque no será restaurado y el disco no será “botable”. Lea la sección
3.5.4. para instrucciones de cómo restaurar una imagen en un tipo de partición diferente del
tipo para el que fue creado.
4.2.4.- Sincronizando en lugar de RestoreDiskImage
Puede mejorar notablemente la velocidad de restauración de una imagen evitando el borrado
de todos los archivos. Si la partición contiene archivos REMBO intentará sincronizar el
contenido de la partición con la imagen de disco. Los ficheros que no hayan cambiado no serán
restaurados, acelerando mucho el proceso. Para usar la sincronización, reemplazar el paso 2
del script de restauración visto en el punto anterior por el siguiente código :
// 2. Sincronización “elegante”
Synchronize(“cache://global/hdimages/win9x/baseimage.img”,
“disk://0:1”,”b”);
Si la partición está corrupta debido a que Windows 9x no se cerró correctamente, el proceso
de sincronización puede fallar. En este caso puede usarse una restauración a prueba de fallos
formateando el disco duro si la sincronización falla.
Ejemplo:
Var SyncErrorHandler (var exc)
{
Log(“Restauración fallida. Reiniciando<br>”);
Prácticas de Empresa 2001/02 1er Turno
Página 65
Manual de Administración del Cliente
// Limpiar partición
HDClean (0,1);
// Esperar 2 segundos
delay(200);
// Reiniciar equipo en modo seguro
Reboot();
}
// Sincronizar:
with (SyncErrorHandler) try {
Synchronice(“cache://global/hdimages/win9x/baseimage.img”,
”disk://0:1”,”b”);
}
Log(“Restauración exitosa<br>”);
4.2.5.- Personalizando
El tratamiento personalizado del ordenador cliente es una fase importante en el proceso de
clonado. En esta fase se establecen parámetros específicos en los ficheros de configuración de
Windows 9x para prevenir conflictos provocados por el hecho de que todos los ordenadores
clonados tengan el mismo nombre. Asimismo se hacen cambios específicos al host o
específicos al hardware.
Dado que Windows 9x está basado en MS-DOS, algunas configuraciones se almacenan en
ficheros, aunque la mayor parte de ella se almacena en registros. Las funciones de
modificación de registro de REMBO Profesional y REMBO Enterprise funcionan solamente en
el registro de sistema de Windows 2000/NT. No obstante podemos usar el programa regedit
para parchear el registro antes de cargar Windows añadiendo la línea correspondiente al
autoexec.bat. Basta con ejecutar un script con REMBO y configurar un parcheado automático
del registro al arrancar (hecho en 4.2.3).
Si desea modificar alguna entrada específica del registro use el siguiente procedimiento
genérico, que resulta más elegante que escribir directamente sobre le registro como vimos en
la sección anterior:
•
•
•
•
•
Bajo Windows 95/98 ejecutar regedit y localizar los parámetros que desea cambiar.
Los ajustes del equipo están almacenados en HKLM/system/CurrentControl (o usar
búsqueda).
Seleccione el trozo que quiere parametrizar y use la función Exportar en el menú para
salvarlo (con la extensión .reg).
Edite el fichero de texto resultante y reemplace los valores deseados.
Suba el fichero modificado al servidor usando netclnt en la consola del servidor.
Añada una línea a su script de restauración para generar un parche de registro
específico del host en el disco, basada en el fichero genérico que ya habíamos subido
al servidor.
Por ejemplo, podríamos usar los siguientes valores:
REGEDIT4
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\VNETSUP]
“ComputerName”=”{$Hostname$}”
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\MSTCP]
“Hostname”=”{$Hostname$}”
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\control\ComputerName\
ComputerName]
“ComputerName”=”{$Hostname$}”
Prácticas de Empresa 2001/02 1er Turno
Página 66
Manual de Administración del Cliente
Asumiendo que ha salvado este fichero en el servidor REMBO en hdimages/win9x/
baseimage.reg puede reemplazar el paso 3b de la sección 4.2.3 por el siguiente comando:
// Paso 3b. Copiar y parchear los ajustes del registro específico del
// host
PatchFile(“cache://global/hdimages/win9x/baseimage.reg”,
”disk://0:1/rembo.reg”);
4.2.6. Imágenes incrementales básicas
Son imágenes que contienen la diferencia entre 2 estados del disco duro, sin tratar las
diferencias en los registros. Los registros son tratados como ficheros modificados y serán
incluidos en la imagen incremental, siendo restaurado a ciegas durante el proceso de
restauración. Esto no causará problemas si trabaja con una única imagen incremental a la vez.
Sin embargo, si quiere usar múltiples imágenes incrementales y unirlas para crear una único
estado final, debe manejar los ficheros de registro explícitamente ya que tiene que unir los
cambios en el fichero de registros así como en los ficheros.
Lo primero que debe hacer antes de crear una imagen incremental es instalar un software o
driver adicional en la estación de trabajo, para tener algo que almacenar en la imagen
incremental.
Para crear la imagen incremental simplemente ejecute Synchronize en modo incremental en
su disco duro. El siguiente ejemplo compara el contenido de la partición entre su imagen básica
y la incremental en el servidor (3r parámetro):
Synchronize(“disk://0:1”,
“cache://global/hdimages/win9x/baseimage.img”,
“>cache://global/hdimages/win9x/baseimage.diff”);
No es necesario que la imagen incremental tenga un nombre similar a la básica.
Para restaurar su imagen incremental sobre la imagen básica, debe unir ambas. La forma
más sencilla de hacerlo es usar una imagen virtual. Una vez que la imagen virtual se ha creado
uniendo las otras 2, puede restaurar esta imagen virtual en la partición de Windows en el modo
de restauración completa. Aquí tenemos un script de ejemplo, similar al de restauración básica
pero con la imagen incremental añadida:
// 1. Abrir los 2 archivos de disco (base y diff)
OpenArchive(“base”,”cache://global/hdimages/win9x/baseimage.img”);
OpenArchive(“diff”,”cache://global/hdimages/win9x/baseimage.diff”);
// 2. Crear una imagen virtual en el archivo base
CreateVirtualImage(“win9x”,”arch://base”);
// 3. Añadir la imagen incremental a la imagen virtual
FileLink(“link://win9x”,”arch://diff”);
// 4. Sincronizar el contenido del disco con la imagen virtual
Synchronize(“link://win9x”,”disk://0:1”,”b”);
// 5. Liberar recursos usados
FreeVirtualImage(“win9x”);
CloseArchive(“diff”);
CloseArchive(“base”);
Nota: Si usa REMBO Classic o no quiere crear imágenes virtuales puede hacer la
sincronización en 2 pasos (más lento):
// 1. Restaurar la imagen base, borrando todos los demás ficheros
Synchronize(“cache://global/hdimages/win9x/baseimage.img”,
“disk://0:1”,”b”);
Prácticas de Empresa 2001/02 1er Turno
Página 67
Manual de Administración del Cliente
// 2. Restaurar la imagen incremental (no-destructiva)
Synchronize(“cache://global/hdimages/win9x/baseimage.diff”,
“disk://0:1”,”b+”);
4.2.7. Imágenes incrementales avanzadas
Necesitará imágenes incrementales avanzadas si quiere unir más de una imagen incremental
con la imagen básica. Las imágenes incrementales avanzadas son más complejas de gestionar
que las básicas, pero son más flexibles. Con ellas puede crear una imagen incremental por
programa, y unirlas con la imagen básica en función de lo que el usuario elija, para luego
restaurarlo al disco rápidamente.
Este es el procedimiento para crear una imagen incremental avanzada:
•
•
•
•
Restaurar la imagen base en la estación de trabajo. Esto se llama estado original.
Desde este estado seguro, instalar el software requerido. Alcanzaremos el estado
final. El objetivo de la imagen incremental es contener las diferencias entre el estado
original y el final, de modo que es posible regenerar el estado final desde el original.
Crear una imagen incremental con los ficheros que han cambiado, excepto los de
configuración del sistema (normalmente el registro, aunque también pueden aparecer
win.ini, system.ini, autoexec.bat y config.sys ...).
Crear parches de configuración genéricos y el script necesario para reproducir los
cambios en los ficheros de configuración.
Aquí están los detalles para la creación de la imagen incremental para ficheros y registros:
Cuando su software esté instalado (punto 2 del procedimiento), inicie REMBO y ejecute
el siguiente script. Este script usa una imagen virtual para cortar los ficheros de registro
según la comparación entre el contenido del disco y la imagen base. La imagen
incremental resultante no contendrá los ficheros de registro :
// 1. Crear una imagen virtual del disco
CreateVirtualImage(“win9x”,”disk://0:1”);
// 2. Cortar los ficheros de registro
RemoveFile(“link://win9x/windows/user.dat”);
RemoveFile(“link://win9x/windows/system.dat”);
// 3. Crear la imagen incremental
Synchronize(“link://win9x”,
“cache://global/hdimages/win9x/baseimage.img”,
“>cache://global/hdimages/win9x/mysoft.diff”);
// 4. Liberar recursos
FreeVirtualImage(“win9x”);
Este script crea la imagen incremental solo para ficheros. Para aplicar los correspondientes
cambios al registro debe crear manualmente un parche del registro comparando el registro de
la imagen base con el registro modificado. Se puede hacer siguiendo este procedimiento:
•
•
•
En un ordenador configurado en el estado original (imagen básica solo) ejecutar
regedit y exportar la rama HKEY_LOCAL_MACHINE a un fichero de texto llamado
baseimage.reg.
En el ordenador donde instaló el software, ejecute regedit y exporte la rama completa
HKEY_LOCAL_MACHINE al fichero de texto mysoft.reg.
Copiar ambos ficheros a un directorio temporal en el ordenador, abrir una ventana de
MS-DOS, y en este directorio, el siguiente comando buscará automáticamente las
diferencias entre las 2 versiones del registro y las almacena en el siguiente fichero:
fc baseimage.reg mysoft.reg > mysoft.diffreg
Prácticas de Empresa 2001/02 1er Turno
Página 68
Manual de Administración del Cliente
•
•
Abrir en un editor de texto los 3 ficheros simultáneamente y editar las diferencias.
Asegúrese de añadir la palabra REGEDIT4 al principio del fichero, seguido de una
línea en blanco, y de tener todos los pares key/value prefijados por el selector
apropiado.
Subir el registro resultante al servidor en hdimages/win9x/mysoft.reg.
4.2.7.1.- Restaurando una imagen incremental avanzada
Se hace en 3 pasos:
•
•
•
Crear una imagen virtual para unir la imagen base con la incremental por ficheros.
Restaurar la imagen virtual.
Instalar el parche del registro.
Los pasos 1 y 3 pueden cambiarse para unir más de una imagen incremental. Una vez ha
entendido cómo funciona para una imagen, puede copiar las sentencias de Rembo-C para
otras imágenes incrementales para crear un script más complejo.
Aquí vemos un ejemplo completo de restauración paso a paso:
// 1. Abrir los archivos de disco
OpenArchive(“base”,”cache://global/hdimages/win9x/baseimage.img”);
OpenArchive(“diff1”,”cache://global/hdimages/win9x/mysoft.diff”);
// 1b. Crear la imagen virtual en la imagen base
CreateVirtualImage(“win9x”,”arch://base”);
// 1c. Unir el archivo incremental con la imagen virtual
LinkTree(“link://win9x”,”arch://diff1”);
// 2. Restaurar los ficheros
// Esto restaurará los ficheros de registro de la imagen base en el
// estado inicial.
Synchronize(“link://win9x”,”disk://0:1”,”b”);
// 2b. Liberar recursos
CloseArchive(“diff1”);
FreeVirtualImage(“win9x”);
CloseArchive(“base”);
// 3a. Configurar todos los parches de registro
str regcmd = “c:\\windows\\regedit”
“ /L:c:\\windows\\system.dat”
“ /R:c:\\windows\\user.dat”;
CreateTextFile(“disk://0:1/rembo.bat”,
regcmd + “ c:\\rembo.reg\n” +
regcmd + “ c:\\mysoft.reg\n”);
// 3b. Instalar el parche de registro del servidor
PatchFile(“cache://global/hdimages/win9x/baseimage.reg”,
“disk://0:1/rembo.reg”);
// 3c. Instalar el parche de registro del software
PatchFile(“cache://global/hdimages/win9x/baseimage.reg”,
“disk://0:1/mysoft.reg”);
Si necesita mezclar más de una imagen incremental con la imagen base, debe hacer los
siguientes cambios al script anterior:
•
•
Extienda el paso 1 y repita el paso 1c para las otras imágenes incrementales (para
mezclar todas las imágenes incrementales en una imagen virtual). No olvide cerrar los
archivos abiertos después de la sentencia Synchronize.
Extienda el paso 3 y repita el paso 3c para los otros parches de registro (para aplicar
secuencialmente todos los parches de registro).
Prácticas de Empresa 2001/02 1er Turno
Página 69
Manual de Administración del Cliente
4.2.7.2.- Yendo mas allá
Cuando empiece a usar restauración incremental avanzada, debería considerar leer la
descripción de todos los comandos relacionados con la restauración de discos, imágenes
virtuales, registro NT y archivos para tener una mejor visión global de los métodos avanzados
de clonación descritos en esta sección.
Hay muchas formas de combinar estos comandos para instalar o restaurar automáticamente
un ordenador dependiendo del hardware, del perfil de usuario, del grupo, etc. Sin embargo,
tales procedimientos van más allá del ámbito de este documento. Con alguna experiencia en
programación y algo de imaginación, usted debería ser capaz de hacer casi cualquier cosa con
REMBO. Si se enfrenta a un problema, puede intentar compartirlo con otros usuarios de
REMBO en el foro de soporte.
Puede también solicitar el REMBO Software Development Kit, el cual incluye mas de cien mil
lineas de código fuente Rembo-C para realizar varias tareas de mantenimiento.
Prácticas de Empresa 2001/02 1er Turno
Página 70
Manual de Administración del Cliente
4.3.- Clonando Windows NT / 2000
Esta sección describe como crear una imagen base Windows NT, como crear imágenes
incrementales y como ajustar su ordenador destino después de una restauración (p.e. cambiar
el nombre del host).
Estas instrucciones están basadas en Windows NT 4.0, pero pueden adaptarse para clonar
puestos de trabajo Windows 2000. La mayoría de las operaciones descritas en esta sección
pueden ser realizadas con los asistentes. Esta sección muestra como llevar a cabo estas
operaciones con scripts Rembo-C.
4.3.1.- Creando una imagen base Windows NT
Esta primera sección describe como crear una imagen completa de su disco duro Windows
NT. Esta imagen es importante ya que será la base para las imágenes incrementales, y
también su copia de seguridad de emergencia si su disco duro se corrompe.
Instale Windows NT en un equipo limpio, sin ningún otro sistema operativo instalado. Durante
la instalación, seleccione DHCP cuando se le pregunte por los parámetros de configuración de
la interface de red. De un nombre a la estación de trabajo, y únala a su dominio o grupo de
trabajo NT.
Arranque REMBO, y ejecute FileMan(“disk://0:1”); para mostrar el contenido de su partición
Windows NT. Entonces, cierre el administrador de archivos y use el siguiente script para crear
la imagen base :
// 1. Crear una imagen virtual del disco
CreateVirtualImage("nt","disk://0:1");
// 2. Eliminar el fichero de paginación de la imagen virtual
RemoveFile("link://nt/pagefile.sys");
// 3. Eliminar versiones previas de los archivos
if(FileExists("cache://global/hdimages/winnt/baseimage.img"))
RemoveFile("cache://global/hdimages/winnt/baseimage.img");
// 4. Crear un archivo de la imagen virtual
Synchronize("link://nt","cache://global/hdimages/winnt/baseimage.img",
"");
// 5. Liberar recursos
FreeVirtualImage("nt");
El script anterior almacena el contenido de su disco duro en un fichero
cache://global/hdimages/winnt/baseimage.img en el servidor. Puede repetir el paso 2 para los
ficheros o directorios que quiera eliminar de la imagen. Los ficheros o directorios eliminados en
el paso 2 no son realmente eliminados del disco duro porque usamos una imagen virtual.
Ahora tiene una copia de seguridad del puesto de trabajo de referencia en el servidor. El
próximo paso es comprobar que la copia de seguridad es correcta.
4.3.2.- Comprobando la imagen de disco base
Ahora debe comprobar que su imagen de disco base funciona restaurando la imagen de
disco. Es recomendable restaurar la imagen en un ordenador diferente del usado para crear la
imagen base para evitar corromper la estación de trabajo de referencia si algo fue mal.
Prácticas de Empresa 2001/02 1er Turno
Página 71
Manual de Administración del Cliente
Arranque REMBO, configure las particiones con los asistentes (no olvide dejar algo de
espacio al final del disco duro para la partición caché). Entonces restaure su imagen Windows
NT con el siguiente comando:
RestoreDiskImage(0,1,”cache://global/hdimages/winnt/baseimage.img”);
Una vez la descarga y la restauración se complete, ejecute FileMan(“disk://0:1”); para mostrar
los ficheros creados en su disco duro.
Escriba NTSetNetbiosName(“NEWNAME”); para cambiar el nombre de su recién creado
puesto de trabajo a “NEWNAME” y ejecute HDBoot(0,1); para arrancar en su partición Windows
NT.
En este punto, usted tiene una copia de seguridad completa de su ordenador de referencia en
caso de problemas durante las próximas etapas de este tutorial. Usted puede volver en
cualquier momento a este estado inicial restaurando la imagen base.
4.3.3.- Crear un script de restauración
Esta sección explica como automatizar el proceso de restauración con un script. Si está
usando Rembo Professional o Enterprise, puede conseguir resultados similares definiendo
acciones de arranque automatizadas usando los asistentes.
Puede usar el siguiente script para restaurar su imagen base a una estación de trabajo. Este
script lleva a cabo las siguientes acciones :
•
•
•
•
Configura las particiones a un estado conocido;
Restaura la imagen base;
Calcula un nombre único para el ordenador y cambia el nombre de la estación de
trabajo NT en el registro de Windows NT;
Arranca.
// 1. Creamos una partición NTFS de 1.5G
SetPrimaryPartitions(0,"NTFS:1500000");
// 2. Restauramos la imagen
RestoreDiskImage(0,1,"cache://global/hdimages/winnt/baseimage.img");
// 3. El nombre está formado por los últimos bytes de la dirección MAC
var hwa = StrParse(NetInfo.MACAddress," ");
str name = "NTRBO-"+hwa[4]+hwa[5];
NTSetNetbiosName(name);
// 4. Arrancamos
HDBoot(0,1);
Para usar el script anterior, guárdelo en un archivo separado, cópielo en el servidor y ejecute
Exec(“net://global/scriptname”); (sustituya scriptname con el nombre de su script).
Para ejecutar el script automáticamente, cree una página HTML conteniendo un mensaje de
bienvenida y una sección <SCRIPT>, como la que hay en el fichero rembo.shtml. Añada la
llamada a la función Exec en la sección script de su página HTML, o simplemente copie y
pegue el contenido del script. Entonces, cambie el parámetro del servidor StartPage para sus
hosts de prueba al URL REMBO de la página HTML que acaba de crear.
Puede ajustar el script a sus necesidades. Si quiere crear dos particiones NTFS, una para el
sistema y otra para los datos, simplemente añada una entrada NTFS:xxx en la cadena de
particiones, y no olvide hacer un formateo rápido a esta partición al menos una vez con
HDClean:
Prácticas de Empresa 2001/02 1er Turno
Página 72
Manual de Administración del Cliente
SetPrimaryPartitions(0,"NTFS:1500000 NTFS:3500000");
HDClean(0,2);
...
Puede usar una variable persistente para determinar si es la primera vez que se ejecuta este
script, y así ejecutar HDClean una sola vez.
4.3.4.- Sincronización en lugar de restauración de una imagen
Se puede mejorar la rapidez del proceso de restauración trasladando todos los ficheros
anteriormente restaurados a un archivo. Si la partición contiene ficheros, REMBO intentará
sincronizar el contenido de la partición con la imagen del disco. Si muchos de los ficheros de
la partición no han sufrido cambios entre dos restauraciones, el modo de sincronización será
más rápido que el de restauración.
Ejemplo :
// 1. Creamos una partición NTFS de 1.5GB
SetPrimaryPartitions (0,”NTFS:1500000”);
// 2.
Synchronize(“cache://global/hdimages/winnt/baseimage.img”,disd://0:1”,
”b”);
// 3. El nombre está formado por los últimos bytes de la dirección MAC
var hwa = StrParse(NetInfo.MACAddress,” ”);
str name = “NTRBO-“+hwa[4]+hwa[5];
NTSetNetbiosName(name);
// 4. Arrancamos
HDBoot(0,1);
Ver la página de sincronización del manual para más información acerca de los diferente
modos de sincronización.
Si la partición está corrupta porque Windows NT se ha apagado correctamente el modo de
sincronización del REMBO debe fallar porque los ficheros están corruptos. Se puede
implementar una restauración fail-safe formateando el disco duro si la sincronización falla al
restaurar la imagen.
Ejemplo :
Var SyncErrorHandler(var exc)
{
Log(“Error en la restauración. Reiniciando …<br>”);
// Limpiamos la partición
HDClean(0,1);
// Esperamos 2 seg
delay(200);
// Reiniciamos el ordenador para comenzar en un estado seguro
Reboot();
}
//Synchronize:
with (SyncErrorHandler) try {
Synchronize(“cache://global/hdimages/winnt/baseimage.img”,
”disk://0:1”,”b”);
Log(“Restauración correcta<br>”);
Prácticas de Empresa 2001/02 1er Turno
Página 73
Manual de Administración del Cliente
4.3.5.- Personalizando
El tratamiento personalizado del ordenador cliente es una fase muy importante en el proceso
clonado. Esta fase permite personalizar parámetros en la estación de trabajo Windows NT para
prevenir conflictos provocados por el hecho de que todos los ordenadores clonados tengan el
mismo nombre o dirección IP.
En Windows NT, todos los parámetros residen en el registro de Windows NT. Prácticamente,
el registro está cargado en varios ficheros : SAM, SOFTWARE, SYSTEM, SECURITY y
DEFAULT. Estos ficheros se encuentran en el directorio /WINNT/system32/config.
Para cambiar el hostname al ordenador puedes usar una de las funciones de alto nivel del
Rembo-C como NTSetNetbiosName. Ver la sección 5.4 en el manual de referencia de scripts
de Rembo-C para más información.
Si quieres modificar una entrada específica del registro usa el siguiente procedimiento:
•
•
•
Bajo Windows NT, ejecuta REGEDIT32 y localiza el parámetro que deseas cambiar. La
configuración del ordenador está almacenada en HKLM/System/ControlSet001.
Determinar en que fichero está localizado el parámetro a modificar. Las entradas
HKLM/Software están cargadas en SOFTWARE, las entradas HKLM/System están
cargadas en SYSTEM, las entradas HKLM/Security están cargadas en SECURITY, las
entradas HKLM/SAM están cargadas en SAM y el perfil de usuario por defecto está
cargada en DEFAULT.
Crear un script que abra el fichero de registro, modificar el valor como se describe en el
reg:página del manual URL y cerramos el registro.
Un ejemplo para cambiar el nombre de usuario mostrado en el diálogo del Windows NT sería
el siguiente:
//
La
clave
winlogon
está
en
el
registro
de
software
OpenRegistry(“soft”,”disk://0:1/winnt/system32/config/software”);
// Almacena el valor ( cadena unicode ) en la clave DefaultUserName.
// La cadena se extiende por varias líneas debido a limitaciones de
// escritura.
// Puedes escribir el mismo commando en una única línea
CreateUnicodeFile(“reg://soft/Microsoft/”
“Windows NT/CurrentVersion/”
“Winlogon/DefaultUserName”,
“Miusuario”);
// Cerrar el registro para realizar los cambios
CloseRegistry(“soft”);
4.3.6.- Imágenes incrementales básicas
Las imágenes incrementales básicas son imágenes que contienen la deferencia entre dos
estados del disco duro, pero sin manejar la diferencia de los registros. Los registros se manejan
como ficheros modificados y serán incluidos en la imagen incremental y actualizados en la
restauración. Esto no produce ningún problema si no trabajamos con más de una imagen
incremental al mismo tiempo porque los registros serán restaurados en el estado de una
imagen incremental. Pero si quieres usar varias imágenes incrementales y combinarlas para
crear un único estado final debemos manejar los ficheros de registro explícitamente porque hay
que combinar los cambios en el fichero de registros.
Lo primero que hay que hacer antes de crear una imagen incremental es instalar un driver
adicional y software sobre la estación de trabajo.
Prácticas de Empresa 2001/02 1er Turno
Página 74
Manual de Administración del Cliente
Crear la imagen incremental simplemente ejecutando Synchronize en el modo incremental
sobre tu disco duro. El siguiente ejemplo compara el contenido de la partición con la imagen
básica y crea una imagen incremental sobre el servidor (tercer parámetro).
Synchronize(“disk://0:1”,
“cache://global/hdimages/winnt/baseimage.img”,
“>cache://global/hdimages/winnt/baseimage.diff”);
El nombre de tu imagen incremental no necesita ser similar al nombre de la imagen básica.
Para restaurar tu imagen incremental sobre tu imagen básica hay que combinarlas. Lo más
sencillo es usar una imagen virtual. Una vez que la imagen virtual está creada combinando la
imagen incremental y la imagen básica se puede restaurar esta imagen virtual sobre la
partición Windows NT en el modo de restauración o en el modo de sincronización.
Un ejemplo de un script para imágenes incrementales sería:
// 1. Abrir dos archivos(base and diff)
OpenArchive(“base”,”cache://global/hdimages/winnt/baseimage.img”);
OpenArchive(“diff”,”cache://global/hdimages/winnt/baseimage.diff”);
// 2. Crear una imagen virtual
CreateVirtualImage(“nt”,”arch://base”);
// 3. Combinar la imagen incremental
FileLink(“link://nt”,”arch://diff”);
y la imagen virtual
// 4.Sincronizar el contenido del disco con la imagen virtual
Synchronize(“link://nt”,”disk://0:1”,”b”);
// 5.Liberar los recursos usados
FreeVirtualImage(“nt”);
CloseArchive(“diff”);
CloseArchive(“base”);
Si estás usando REMBO Classic, o si deseas usar imágenes virtuales, puedes conseguir un
resultado similar haciendo:
// 1. Restaurar la imagen básica
Synchronize(“cache://global/hdimages/winnt/baseimage.imag”,
“disk://0:1”,”b”);
// 2. Restaurar la imagen incremental (non-destructive)
Synchronize(“cache://global/hdimages/winnt/baseimage.deff”,
“disk://0:1”,”b+”);
4.3.7.- Imágenes incrementales avanzadas
Necesitarás usar imágenes incrementales avanzadas si deseas combinar más de una imagen
incremental con la imagen básica. Las imágenes incrementales avanzadas son más complejas
de manejar que las imágenes incrementales básicas pero permiten mas flexibilidad. Con las
imágenes incrementales avanzadas puedes crear una imagen incremental por programa, y
unirlas junto con la imagen básica dependiendo de lo que elija el usuario, restaurándola al
disco rápidamente.
El proceso a seguir para crear una imagen incremental avanzada es el siguiente:
•
•
•
•
•
Restaurar la imagen básica sobre la estación de trabajo. Esto es el estado original.
Desde este estado, instalar el software requerido. El ordenador estará en el estado
final.
Crear una imagen incremental de todos los ficheros excepto los ficheros de registros.
Por cada fichero de registro, crear una imagen de registro incremental
El resultado son seis imágenes incrementales : una imagen incremental de todos los
ficheros y cinco por los ficheros del registro.
Prácticas de Empresa 2001/02 1er Turno
Página 75
Manual de Administración del Cliente
Cuando tu programa esté instalado, inicia REMBO y ejecuta el siguiente script.
// 1. Crea una imagen virtual del disco
CreateVirtualImage(“nt”,”disk://0:1”);
// 2. Corta el directorio de registro
DelTree(“link://nt/winnt/system32/config”);
// 3. Crea la imagen incremental
Synchronize(“link://nt”, “cache://global/hdimages/winnt/baseimage.img”,
“>cache://global/hdimages/winnt/mysoft.diff”);
// 4. Libera recursos
FreeVirtualImage(“nt”);
Este script crea la imagen incremetal para los ficheros. Si queremos crear las imágenes
incrementales para los ficheros de registro debe seguir las siguientes instrucciones para cada
una de los cinco ficheros de registros. Este script crea una imagen incremental entre el estado
original del fichero del registro y el estado actual (estado final). Remplaza la palabra SYSTEM
por SOFTWARE, SAM, SECURITY y DEFAULT para crear las otras cuatro imágenes
incrementales. No hay que olvidar que hay que cargar esas cinco imágenes en cinco ficheros
diferentes sobre el servidor (cambiar la extensión del tercer argumento en Synchronize).
//1. Abrir la imagen básica para obtener el fichero de registro original
OpenArchive(“base”,”cache://global/hdimages/winnt/baseimage.img”);
//2. Abrir el registro en la imagen básica (estado inicial)
OpenRegistry(“initial”,”arch://base/winnt/system32/config/SYSTEM”);
//3. Abrir el registro sobre el disco(estado final)
OpenRegistry(“final”,”disk://0:1/winnt/system32/config/SYSTEM”);
//4. Crear la imagen incremental
Synchronize(“reg://final”,”reg://initial”,
”?>cache://global/hdimages/winnt/mysoft.sys”);
//5. Liberar recursos
CloseRegistry(”final”);
CloseRegistry(”initial”);
CloseArchive(”base”);
4.3.7.1.- Restaurando una imagen incremental avanzada
Hay que seguir tres pasos:
•
•
•
Crear una imagen virtual para combinar la imagen básica con la imagen incremental
para los ficheros.
Restaurar la imagen virtual.
Aplicar las imágenes incrementales de registros.
El primer paso puede combinar más de una imagen incremental. El paso tercero es el más
complejo de los tres. Las imágenes incrementales de registros contienen las diferencias entre
el estado inicial y el estado final para una registro. Para aplicar la imagen incremental debemos
ejecutar Synchronize en modo “+-“.
Ejemplo :
// 1a. Abrir los archivos baseimage.img y mysoft.diff
OpenArchive(“base”,”cache://global/hdimages/winnt/baseimage.img”);
OpenArchive(“diff1”,”cache://global/hdimages/winnt/mysoft.diff”);
// 1b. Crear
una imagen virtual
Prácticas de Empresa 2001/02 1er Turno
Página 76
Manual de Administración del Cliente
CreateVirtualImage(“nt”,”arch://base”);
// 1c.Combinar el archivo incremental en la imagen virtual.
LinkTree(“link://nt”,”arch://diff1”);
// 2a.Restaurar los ficheros.
// Esto restaurará los ficheros del registro desde la imagen básica en
//el estado inicial
Synchronize(“link://nt”,”disk://0:1”,”b”);
// 2b.Liberar recursos
CloseArchive(“diff1”);
FreeVirtualImage(“nt”);
CloseArchive(“base”);
// 3a.Abrir el fichero del registro
OpenRegistry(“openreg”,”disk://0:1/winnt/system32/config/SYSTEM”);
// 3b.Añadir la imagen incremental del registro
Synchronize(“cache://global/hdimages/winnt/mysoft.sys”,”reg://openret”,
”+-“);
// 3c.Cierra el fichero del registro
CloseRegistry(“openreg”);
Como se puede observar el ejemplo está incompleto, los pasos 3a, 3b y 3c deben repetirse
para cada uno de los cinco ficheros del registro (remplazar SYSTEM y .sys).
Si deseas combinar más de una imagen incremental debes realizar las siguientes
modificaciones en el script:
•
•
Ampliar el paso 1a y repetir el paso 1c para cada imagen incremental (combinar todas
las imágenes incrementales en una imagen virtual). No olvide cerrar los archivos
abiertos después de Synchronize.
Repetir el paso 3b para las demás imágenes incrementales y para cada fichero del
registro.
4.3.8.- Ficheros comprimidos
REMBO no puede acceder a ficheros comprimidos sobre un volumen NTFS. Si
intentamos abrir un fichero comprimido el sistema de fichero lanzará una excepción. Cuando
usamos Synchronize para regresar a la partición NTFS, los ficheros comprimidos saltarán con
un mensaje warning mostrado en la consola log.
Cuando creamos una imagen de la partición NTFS con REMBO, debería comprobar que no
hay ficheros comprimidos sobre la partición NTFS antes de que se ejecute Synchronize. Para
descomprimir un fichero en Windows NT hay que hacer click sobre el fichero y elegir Properties
desde el menú contextual.
Hay dos situaciones en las que los ficheros comprimidos pueden crearse sobre la partición
NTFS:
•
Cuando instalas el Windows 2000 y la carpeta dllcache está comprimida por
defecto.Tendrás que descomprimir esta carpeta antes de la creación de una imagen de
la partición NTFS con REMBO. La carpeta dllcache esta oculta por defecto.
•
Cuando instalas sobre la estación de trabajo Windows NT un nuevo paquete de
servicio tienes la opción de volver a los ficheros existentes si quieres desintalar dicho
paquete.
Prácticas de Empresa 2001/02 1er Turno
Página 77
Manual de Administración del Cliente
4.3.9.- Parcheando el SID de NT con REMBO
Esta sección explica paso a paso como remplazar el SID sobre un partición NTFS y en
ficheros del registro NT.
En este ejemplo mostramos como restaurar una imagen NTFS cargada en
cache://global/ntbase.img a la primera partición, usando el on-the-fly SID sustituyendo rutinas
de REMBO. Además, mostramos como salvar el SID generado en un fichero host específico
para usar este SID en posteriores restauraciones.
1. Extraer el SID original de la imagen del disco duro, y cargarla en la variable binaria
oldsid.
OpenArchive(“nt”,”cache://global/ntbase.img”);
var oldsid = GetSIDFromRegistry(“arch://nt/winnt/system32/config/sam”);
CloseArchive(“nt”);
2. Generar para este host un único SID o usar el SID cargado en el fichero net://host/SID.
Cargar este nuevo fichero en la variable binaria newsid.
var newsid;
if (!FileExists(“net://host/SID”)) {
//no carga SID
newsid=GenerateSID(oldsid);
//generar
CreateHexFile(“net://host/SID”,newsid);
//carga
}else{
//usa el SID cargado
mewsid=LoadHexFile(“net://host/SID”);
3. Restaurar la imagen del disco
HDClean(0,1);
ApplySID(“disk://0:1”,oldsid,newsid);
Synchronize(“cache://global/ntbase.img”,”disk://0:1”,”b”);
4. Remplazar SID en los ficheros del registro
PatchSID(oldsid,newsid);
Prácticas de Empresa 2001/02 1er Turno
Página 78
Manual de Administración del Cliente
4.4.- Clonar Linux
4.4.1.- Creación de una imagen base Linux
El primer paso de la creación de la imagen del disco es instalar el sistema Linux en la
máquina modelo, personalizándola según las necesidades. Siempre que sea posible hay que
intentar instalar la distribución en una única partición. Si queremos utilizar distintas particiones,
deberemos crear una imagen para cada una.
A la hora de la creación de la imagen tenemos dos posibilidades:
•
•
Crear una imagen de la distribución completa. Hay que tener en cuenta que la
restauración de la imagen toma su tiempo.
Copiar distintas partes de la distribución ( p.e. /usr ) a un servidor NFS y quitar estas
partes de la partición principal. De esta forma creamos imágenes más pequeñas, pero
a costa de reducir el rendimiento de la máquina debido a que debe acceder al servidor
NFS en tiempo de ejecución.
Cuando tu máquina modelo esté lista ejecuta el siguiente script para crear la imagen. Si
tenemos varias particiones tendremos que ejecutarlo en cada partición.
// Creación de una imagen de la partición 1 (/dev/hda1)
BuildDiskImage (0,1,”cache://global/hdimages/linux/baseimage.base”);
Si tenemos varias particiones y queremos crear una imagen que las contenga a todas
debemos utilizar una imagen virtual para fusionar todas las particiones en un sistema de
archivos virtual. El siguiente ejemplo asume que la partición raíz es /dev/hda1, /usr es
/dev/hda5 y /home es /dev/hda6 :
// 1. Crear una imagen virtual con la partición raíz (hda1)
CreateVirtualImage(“linux”,”disk://0:1”);
// 2. Añadir /usr a la imagen virtual (hda5)
LinkTree(“link://linux/usr”,”disk://0:5”);
// 3. Añadir /home a la imagen virtual (hda6)
LinkTree(“link://linux/home”,”disk://0:6”);
// 4. Crear una imagen en disco de la imagen virtual
Synchronize(“link://linux”,
”cache://global/hdimages/linux/baseimage.base”,” “);
No es necesario crear una imagen para la partición de intercambio, ya que no contiene datos
importantes y REMBO la crea automáticamente al arrancar.
4.4.2.- Arrancar un kernel de Linux
El siguiente paso para la clonación de un sistema Linux es probar tu imagen modelo en una
nueva estación de trabajo.
Para arrancar un kernel de Linux utilizamos la función LXBoot. El primer parámetro es el
archivo que contiene el núcleo y el tercer parámetro contiene los parámetros del núcleo. La
imagen del núcleo debe estar en formato zImage o bzImage. Estos dos formatos son los
estándar que se utilizan en los makefiles para compilar los fuentes del núcleo. No es necesario
etiquetar los núcleos para usarlos con REMBO. El segundo parámetro de LXBoot, el disco de
arranque inicial, no es necesario en esta descripción.
Prácticas de Empresa 2001/02 1er Turno
Página 79
Manual de Administración del Cliente
Para poder utilizar LXBoot debemos extraer el kernel de nuestro disco duro. Para ello
podemos utilizar los asistentes o hacerlo manualmente copiando el archivo del núcleo al
servidor ( con CopyFile ). Las imágenes de los núcleos suelen estar guardadas en /boot. P.e.:
CopyFile(“disk://0:1/boot/vmlinuz”,
”cache://global/hdimages/linux/basekernel.krn”);
Para arrancar la imagen del núcleo desde el sistema de archivos raíz instalado en /dev/hda1 :
LXBoot(“cache://global/hdimages/linux/basekernel.krn”,
” “,”root=/dev/hda1”);
4.4.3.- Probar la imagen base del disco
Recomendamos que pruebes la imagen base en una máquina diferente antes de instalarla en
otras máquinas o modificar la máquina de referencia. Cuando la imagen esté correcta, puedes
usarla como copia de seguridad para la máquina de referencia si algo va mal en los pasos
siguientes de la clonación.
Arranca REMBO en una nueva máquina, y crea las particiones que necesites. No olvides
crear una partición de intercambio. A continuación restaura la imagen que creaste en la
sección anterior con RestoreDiskImage. El siguiente script muestra como podemos llamar a
todas estas funciones :
// 1. Crea una partición linux de 800 Mb y una de intercambio de 128 Mb
SetPrimaryPartitions(0,”EXT2:800000 EXT:128000”);
SetLogicalPartitions(0,”LINUX-SWAP:128000”);
// 2. Restaura la imagen base
RestoreDiskImage(0,1,”cache://global/hdimages/linux/baseimage.base”);
// 3. Limpia la partición de intercambio
HDClean(0,5);
// 4. Lanza el kernel
LXBoot(“cache://global/lxkernel”,” “,”root=/dev/hda1”);
Es importante comprender que la única forma de arrancar la imagen de Linux es a través de
una llamada a LXBoot. Si intentas ejecutar HDBoot(0,1) fallará porque los archivos que se
requieren para el gestor de arranque LILO se han cambiado durante la restauración.
Puedes utilizar este script como el script de restauración para las máquinas Linux colocando
el contenido dentro de una etiqueta SCRIPT en una página HTML, y mediante StartPage hacer
referencia a esta página.
4.4.4.- Creación de un script de restauración
Podemos utilizar el script creado en la sección anterior para restaurar imágenes Linux en el
disco duro. Este script utiliza RestoreDiskImage para instalar la imagen en el disco. Esta
función siempre realiza una restauración completa de la imagen del disco.
Podemos utilizar Synchronize para los mismos propósitos que BuildDiskImage, pero sin
tener que formatear la partición de destino. Cuando la partición ya contiene archivos
Synchronize construye una lista de diferencias entre la imagen base y los archivos que hay en
disco y copia únicamente los archivos que necesitan ser copiados y borra solo aquellos que
necesitan ser borrados. Este proceso es mucho más rápido que BuildDiskImage si solo se
cambian unos cuantos archivos entre restauraciones consecutivas.
Prácticas de Empresa 2001/02 1er Turno
Página 80
Manual de Administración del Cliente
Si hemos optado por la sincronización en vez de una restauración completa, debemos tener
en cuenta que si la partición se corrompe Synchronize fallaría al restaurar la imagen. Para
solventar esta situación podemos utilizar un manejador de excepciones que capture los errores
generados por Synchronize. Si ocurre un error simplemente formatearíamos la partición
destino y reiniciaríamos. Esto devolverá a REMBO a un estado seguro y Synchronize será
capaz de restaurar todos los archivos.
A continuación mostramos un ejemplo de script de sincronización a prueba de fallos :
// Manejador de excepciones
var SyncErrorHandler ( var exc )
{
Log( “Se ha producido un error. Reiniciando ... <br>”);
// Formatea la partición destino
HDClean(0,1);
// Espera 2 segundos
delay(200);
//Reinicia
Reboot();
}
// Sincronización
with(SyncErrorHandler) try {
Synchronize(“cache://global/hdimages/linux/baseimage.base”,
”disk://0:1”,”b”);
}
4.4.5.- Imágenes incrementales de Linux
Para crear una imagen incremental de Linux simplemente debemos ejecutar Synchronize en
modo incremental.
Ejemplo :
// Crea una imagen incremental entre el contenido actual del disco y la
// imagen base
Synchronize(“disk://0:1”,”cache://global/hdimages/linux/baseimage.base”,
“>cache://global/hdimages/linux/mysoft.diff”);
Para restaurar esta imagen incremental debemos utilizar una imagen virtual para fusionar la
imagen base con la imagen incremental.
Ejemplo :
// 1. Abrir los archivos del disco
OpenArchive(“base”,”cache://global/hdimages/linux/baseimage.base”);
OpenArchive(“diff”,”cache://global/hdimages/linux/mysoft.diff”);
// 2. Creación de una imagen virtual sobre la imagen base
CreateVirtualImage(“lx”,”arch://base”);
// 3. Fusionar la imagen incremental en la imagen virtual
LinkTree(“link://lx”,”arch://diff”);
// 4. Sincronizar la imagen virtual al disco
Synchronize(“link://lx”,”disk://0:1”,”b”);
// 5. Liberar recursos
FreeVirtualImage(“lx”);
CloseArchive(“diff”);
CloseArchive(“base”);
Prácticas de Empresa 2001/02 1er Turno
Página 81
Manual de Administración del Cliente
4.4.6.- Personalizar scripts de arranque de Linux
Generalmente las máquinas Linux no necesitan tanta personalización como las máquinas
Windows. Esto es así porque las máquina Linux están mejor integradas dentro de una
infraestructura de red.
Para reducir las necesidades de personalización al mínimo configura tu imagen base con
configuración automática de red mediante DHCP y añade un comando en /etc/rc.d/rc.local
para ejecutar un script ubicado en el servidor. Este script puede realizar tareas basadas en la
dirección IP de la máquina local ( suponiendo que se ha guardado la dirección IP en una
variable de entorno ).
Si utilizamos las características de autentificación de REMBO puedes utilizar la información
recogida durante la autentificación ( normalmente usuario y password ) para manejar tus scripts
de arranque Linux. P.e.: podríamos arrancar X automáticamente mediante el comando
su –l –c startx $username. Utiliza la función PatchFile para crear un script que le de valor a la
variable $username.
Ejemplo :. Iniciar X según el nombre de usuario
chown $username /dev/console /dev/fd0
chmod 622 /dev/console
su –l –c startx $username
Prácticas de Empresa 2001/02 1er Turno
Página 82
MANUAL DE REFERENCIA DE REMBO-C
Manual de referencia de Rembo-C
CAPÍTULO 1 : El lenguaje de scripts de Rembo-C
1.1.- Utilidad
Los scripts nos van a permitir realizar operaciones de mantenimiento automáticas y una serie
de operaciones especiales que los asistentes proporcionados por el programa no pueden llevar
a cabo. También permiten realizar imágenes de disco de forma automática.
Los clientes cargan al iniciar Rembo una página de inicio ( por defecto, rembo.shtml ). El
código del script se coloca entre las etiquetas <SCRIPT> de la página.
Atención : No se recomienda modificar dicha página puesto que las actualizaciones del
programa escribirán sobre ellas. Si se quiere incluir código personalizado se recomienda variar
la página de inicio de los clientes.
1.2.- Añadiendo scripts a las páginas Web
El código de un script puede colocarse en dos lugares :
•
•
Entre dos etiquetas <SCRIPT>.
En llamadas a manejadores de eventos.
Para que un script sea ejecutado por REMBO es necesario declararlo de tipo text/rembo-c,
como sigue:
<script type=”text/rembo-c”>
código del script
</script>
Si no se hace así REMBO ignorará el código.
Las llamadas a manejadores de eventos son fragmentos de código Rembo-C que se ejecutan
al producirse un evento ( ver ejemplos en manual de referencia ). Se definen con el atributo “on
... “.
1.3.- Creación de interfaces de usuario dinámicos
La mayoría de interfaces modernos cambian su aspecto de forma dinámica cuando el usuario
interactúa con ellos.
Aunque el interfaz de usuario del REMBO está basado en HTML, se puede lograr este
comportamiento dinámico usando scripts.
Se puede cambiar el aspecto y el contenido de un elemento de dos formas: usando el sistema
de ficheros, que vuelca la jerarquía de páginas en un árbol de ficheros, o usando las pseudovariables correspondientes. Ambas son casi equivalentes, y cada una de ellas puede ser más
útil que la otra en determinadas circunstancias.
Cuando se accede a un elemento a través del sistema de ficheros, cada directorio
corresponde a un elemento. En cada directorio aparecen dos archivos especiales: SELF y
Prácticas de Empresa 2001/02 1er Turno
Página 85
Manual de referencia de Rembo-C
SELF-APPEND. Cuando sobreescribimos SELF el elemento es destruido y reconstruido a partir
del texto HTML escrito en el fichero.
Cuando sobreescribimos SELF-APPEND, el elemento intentará añadir el código HTML escrito
en el fichero a su propia definición ( esto no es soportado por todos los elementos ). Si leemos
SELF podemos obtener algo de información sobre el contenido del elemento, pero no se
garantiza devolver código HTML que represente completamente el estado actual del mismo.
En los manejadores de eventos es más conveniente acceder a los elementos mediante
variables, ya que cualquier hilo que maneje eventos está ligado a la ventana que provocó el
evento y puede acceder, por tanto, a sus elementos con nombre directamente, como cualquier
variable global.
Ver como ejemplo el código fuente de los asistentes.
1.4.- Creación de plug-ins precompilados ( librerías )
Se pueden precompilar los ficheros en módulos .rbc en .rbx para no mostrar el código fuente
de los mismos. Para ello se usa el compilador rbcc que incluye el kit opcional de desarrollo en
Rembo Profesional o en Rembo Empresa.
Los usuarios de Rembo Clásico solo pueden usar módulos del fabricante o código fuente
directamente.
Prácticas de Empresa 2001/02 1er Turno
Página 86
Manual de referencia de Rembo-C
CAPÍTULO 2 : El lenguaje
2.1.- Estructura de un programa Rembo-C
La sintaxis del lenguaje Rembo-C es muy similar a la del lenguaje C. Destacamos las
siguientes características :
•
•
Es sensible a mayúsculas y minúsculas.
Un programa está compuesto por un grupo de sentencias, que pueden ser :
1.
2.
3.
4.
5.
6.
•
Una sentencia compuesta.
Una declaración de variable o un tipo estructurado.
Una declaración de una función.
Una expresión ( también llamadas a una función ).
Una sentencia de control (if,while,do,for,switch,... ).
Una directiva pragma.
Los comentarios son del tipo /* ... */ o del tipo //.
2.2.- Declaraciones de variables y tipos
Los tipos básicos del lenguaje Rembo-C son los siguientes:
•
•
•
•
int Enteros de 32 bits con signo.
bool
True o False.
str Cadenas.
var Variables.
Las variables tienen las siguientes características :
•
•
•
•
Son similares a las del lenguaje C.
Pueden tomar un valor inicial.
Mediante el modificador const se indica que es de sólo-lectura.
Para que sean visibles solamente dentro de un módulo se pueden declarar localmente
dentro de una sentencia compuesta.
Las tablas se caracterizan por:
•
•
•
•
Se definen igual que en C.
Si no se especifica en su declaración un tamaño son dinámicas.
La inicialización se puede realizar incluyendo los elementos entre llaves. Los elementos no
inicializados se ponen a “cero”.
Las tablas multidimensionales no pueden declararse directamente. Hay que usar una tabla
de vars, siendo cada una de ellas una tabla en sí misma.
Los tipos definidos por el usuario son dos: el tipo enumerado y las estructuras. Pueden
ligarse a un nombre para usarse posteriormente o declarar inmediatamente una o más
variables.
La sintaxis del tipo enumerado es la siguiente :
enum [nombre]{
elementos
} [lista de variables];
Prácticas de Empresa 2001/02 1er Turno
Página 87
Manual de referencia de Rembo-C
No es como en C: puede usarse donde se necesite una variable numérica, pero también
donde se requiera una variable cadena.
La sintaxis de una estructura es la siguiente :
struct [nombre]{
declaración de campos
} [lista de variables];
La inicialización de una estructura es como la de una tabla. Pueden anidarse libremente.
2.3.- Declaración de funciones
Son como las del lenguaje C. En la cabecera de una función sólo pueden aparecer tipos
básicos y el tipo void. En los argumentos var o en los valores de retorno puede devolverse
cualquier objeto ( ¡ incluso funciones ! ).
Los tipos int, bool y str se pasan por valor. El tipo var se pasa por referencia.
No es necesario prototipar las funciones, ya que el tipo de los argumentos y de los valores de
retorno se comprueba en tiempo de ejecución.
Al contrario que en el lenguaje C, Rembo-C puede devolver variables localizadas
automáticamente ( p.e.: tablas ), puesto que incluye un recolector de basura automático que
elimina el objeto en cuanto no sea necesario.
Para declarar funciones locales se hace igual que las variables locales.
2.4.- Expresiones
Las tenemos de cuatro tipos : numéricas, booleanas, cadena y variable.
La comprobación de tipos para las 3 primeras es rígida. La de las variables se realiza en
tiempo de ejecución, permitiendo un cierto grado de polimorfismo.
Rembo-C le asigna mayor prioridad a las operaciones a nivel de bit que a las de comparación.
En Rembo-C no se permite la evaluación en cortocircuito de expresiones booleanas ni
condicionales : se comprueba la expresión completa aunque la evaluación de la primera ya
resuelva el valor de la expresión entera.
Los constructores de tablas son los siguientes:
•
•
Tablas sin inicializar: tipo_básico[tam] siendo tam opcional.
Tablas inicializadas: {elem1, elem2, ... , elemn} donde elemi puede ser cualquier expresión.
La comprobación de rangos es automática. Si se accede a una tabla dinámica con un índice
mayor que el tamaño de la misma, no aparece un error, sino que se aumenta su tamaño hasta
que dicho elemento pueda existir.
Las cadenas pueden accederse de la misma forma que las tablas. A menos que hayan sido
declaradas como const crecen automáticamente al acceder a una posición mayor que su
longitud. Las posiciones intermedias se rellenan con espacios.
Prácticas de Empresa 2001/02 1er Turno
Página 88
Manual de referencia de Rembo-C
2.5.- Sentencias de control
Son las mismas que el C:
•
•
•
•
•
•
•
•
•
if ( ... ) ... [else ... ]
while ( ... ) ...
do ... while ( ... );
for ( ... ; ... ; ... ) ...
switch ( ... ) { case ... : ... [ default : ... ] }
break;
continue;
goto ...;
return [ ... ];
Las condiciones del if y del while han de ser de tipo bool.
Las expresiones de la sentencia case pueden ser expresiones de cualquier tipo compatible
con la expresión del switch correspondiente.
2.6.- Hilos ( threads )
La máquina virtual REMBO (MV) es multihilo. La ejecución es multitarea de tipo preemptive
en tiempo real. Cada tarea tiene una porción del tiempo total de procesador. Las primitivas son
atómicas y pueden superar su porción.
Se crea un nuevo hilo para el manejador de eventos HTML, las excepciones o cuando se
produce una llamada a las primitivas exec o eval. Estas primitivas devuelven un IDThread que
se puede usar para interactuar con dicho hilo.
La primitiva SELF devuelve el IDThread del hilo actual.
Mediante la orden join( IDThread ) hacemos que el hilo actual espere a que termine el hilo
indicado por IDThread. El hilo actual no usa su porción de tiempo y cuando le toca pasa el
control de nuevo inmediatamente.
Con la orden delay( num ) hacemos que el hilo actual espere durante las centésimas de
segundo indicadas por num. El hilo actual no usa su porción de tiempo y cuando le toca pasa el
control de nuevo inmediatamente.
Con la orden KillThread eliminamos el hilo actual.
No se han implementado aún mecanismos de acceso concurrente a una variable. Sin
embargo, se resuelve casi por completo porque las operaciones y las primitivas de la máquina
virtual son atómicas.
2.7.- Manejo de excepciones
Si se produce un error Rembo eleva una excepción. Esto provoca la suspensión temporal del
hilo que la provocó y se crea un nuevo hilo que ejecuta el manejador de excepciones.
Con with ... try se puede definir un manejador local de excepciones.
Prácticas de Empresa 2001/02 1er Turno
Página 89
Manual de referencia de Rembo-C
Las funciones de dicho manejador son:
•
•
Almacena o indica la excepción.
Decide que hacer a continuación :
1. Propagar la excepción ( por defecto ).
2. Resumir la ejecución del hilo a partir del bloque try.
3. Eliminar el hilo que provocó el error con KillThread y cancelar la propagación de la
excepción.
Si no se define un manejador local, o si la excepción ha sido propagada, se llama a la función
predefinida ExceptionHandler. Por defecto las acciones que realiza son las siguientes :
•
•
•
Mata al hilo que la provocó.
Muestra un mensaje de error en la pantalla.
Lo manda al servidor usando SysLog.
El argumento de dicha función es una estructura que nos indica el tipo de excepción que se
ha producido.
Si se produce una excepción dentro de un manejador se eliminan ambos.
Es posible provocar una excepción con la orden RaiseError.
2.8.- Programación orientada a objetos
Rembo-C no es un lenguaje orientado a objetos. Sin embargo, es posible adaptarlo fácilmente
para ello.
Ver el ejemplo en el manual.
2.9.- Directivas pragma
Son tres :
•
#pragma purge <variable global>
Elimina la definición de una variable global.
•
#pragma clear <variable global>
Resetea el contenido de la variable a NIL. Útil para las variables protegidas.
•
#pragma protect <variable >
Evita que la variable cambie su tipo con las expresiones =, := o<=>.
2.10.- Palabras reservadas
Estas palabras no pueden ser redefinidas ni usarse como identificadores. Son las siguientes :
•
•
•
•
•
int, bool, str, var, const.
void, enum, struct.
NIL, sizeof, typeof.
if, else, switch, break, case, default.
for, while, do, continue, goto, return.
Prácticas de Empresa 2001/02 1er Turno
Página 90
Manual de referencia de Rembo-C
•
•
•
join, delay, SELF.
with, try.
Pragma, purge, clear, protect, debug.
2.11.- Resumen de diferencias entre C y Rembo-C
•
Sintaxis
1.
2.
3.
4.
5.
No existen constantes de tipo carácter: se usan cadenas de un solo carácter.
Es posible anidar declaraciones de funciones.
Se permiten colocar sentencias fuera de las funciones.
Se puede declarar una variable en todo lugar donde se permitan sentencias.
No hay modificador static, pero las variables locales hacen la misma función.
•
Operadores
1.
2.
3.
4.
5.
6.
Se pueden usar los operadores +, <, <=, >=, >, ==, != con cadenas.
Los operadores a nivel de bit tienen mayor prioridad que los relacionales.
Los operadores booleanos y condicionales no ejecutan evaluación en cortocircuito.
Aparecen dos nuevos operadores ( <=> y := ) para manipular variables.
El operador [ ] proporciona comprobación automática de rangos.
El operador sizeof nos da el número de elementos de una tabla o estructura, la
longitud de una cadena u objeto binario, o –1 en caso de valores atómicos.
7. El operador typeof nos devuelve el nombre del tipo de cualquier objeto.
•
Variables
1.
2.
3.
4.
5.
Los enteros no son equivalentes a los booleanos. Usa el tipo bool.
Solo hay una clase de número: enteros de 32 bits con signo.
Las cadenas son un tipo básico ( str ).
Todas las variables se inicializan implícitamente a un valor “cero”.
No hay punteros como en el lenguaje C. El tipo var permite almacenar referencias a
objetos.
Las constantes enumeradas no se manejan como constantes sino como cadenas.
Las tablas sin tamaño inicial indicado son dinámicas.
Los valores iniciales tanto de tablas como de estructuras no tienen por qué ser constantes.
No hay uniones.
6.
7.
8.
9.
Prácticas de Empresa 2001/02 1er Turno
Página 91
Manual de referencia de Rembo-C
CAPÍTULO 3 : Bibliotecas de funciones
Las bibliotecas incluidas con Rembo-C son muy similares a las que se incluyen con la
mayoría de los lenguajes.
Podemos dividirlas en varias categorías :
•
•
•
•
•
•
•
•
•
•
•
Cadenas.
Objetos binarios.
Tablas y estructuras.
Directorios.
Ficheros.
Contenido de un fichero.
Interfaz de usuario.
Primitivas relacionadas con la evaluación.
Variables persistentes.
Primitivas relacionadas con la red.
Primitivas del sistema.
Con este documento no pretendemos resumir una por una todas las funciones incluidas en las
librerías: solo destacaremos las que nos han parecido más útiles.
Para informarse detalladamente de su uso y ver otras que pueden ser útiles en determinadas
circunstancias es recomendable consultar el manual de referencia del lenguaje. .
3.1.- Cadenas
Nombre
StrCopy
Prototipo
str StrCopy ( str origen, int pos_inic, int pos_final );
Descripción
Página
Duplica el fragmento indicado entre pos_inic y pos_final de la cadena origen.
339
Nombre
StrCompare
Prototipo
int StrCompare ( str cad1, str cad2 );
Descripción
Compara las dos cadenas y devuelve:
-1 si cad1 < cad2.
0 si cad1 = cad2.
1 si cad1 > cad2.
Página
Es sensible a mayúsculas y minúsculas.
344
Prácticas de Empresa 2001/02 1er Turno
Página 92
Manual de referencia de Rembo-C
Nombre
StrToUpper / StrToLower
Prototipo
str StrToUpper / StrToLower ( str cad );
Descripción
Página
Devuelve la representación en mayúsculas / minúsculas de la cadena dada.
354 / 355
3.2.- Objetos binarios
Nombre
BinCreate
Prototipo
var BinCreate ( int tam, int valor_inicial );
Descripción
Página
Crea un nuevo objeto binario de tam bytes y los inicializa con valor_inicial.
365
3.3.- Tablas y estructuras
Nombre
DeepCopy
Prototipo
var DeepCopy ( var objeto );
Descripción
Página
Duplica de forma recursiva el objeto dado, incluso si dicho objeto es una
variable compleja que contiene, p.e., tablas de estructuras o tablas anidadas.
386
Nombre
DeepFreeze
Prototipo
var DeepFreeze ( var objeto, bool solo_lectura );
Descripción
Protege todos los elementos de la variable objeto. Si solo_lectura vale
FALSE sólo se evita que puedan cambiar de tipo. En otro caso también se
convierte en una variable de sólo lectura.
388
Página
3.4.- Directorios
Nombre
CreateDir / Mkdir
Prototipo
void CreateDir / Mkdir ( str path );
Descripción
Página
Crea el directorio indicado en la localización indicada en el path.
393
Prácticas de Empresa 2001/02 1er Turno
Página 93
Manual de referencia de Rembo-C
Nombre
RemoveDir / RmDir
Prototipo
void RemoveDir / Rmdir ( str path );
Descripción
Página
Elimina el directorio indicado en la localización indicada en el path.
395
Nombre
CopyTree / MoveTree
Prototipo
Void CopyTree / MoveTree ( str path_orig, str path_dest );
Descripción
Página
Copia / Mueve recursivamente el directorio indicado en el path_orig al
path_dest..
396 / 397
Nombre
ChDir
Prototipo
void ChDir ( str path );
Descripción
Página
Cambia el path del directorio actual de REMBO al indicado en el path.
399
3.5.- Ficheros
Nombre
CopyFile / FileCopy
Prototipo
void CopyFile / FileCopy ( str path_orig, str path_dest);
Descripción
Página
Copia el fichero indicado en el path_orig al path_dest.
402
3.6.- Contenido de un fichero
Nombre
FileOpen
Prototipo
var FileOpen ( str path, str modo );
Descripción
Página
Abre el fichero indicado en el path con el modo indicado y devuelve un
descriptor de fichero asociado.
429
Nombre
FileRead
Prototipo
int FileRead ( var fich, var obj, int pos_inic, int long );
Descripción
Lee long bytes del fichero indicado por el descriptor de fichero fich a partir de
la posición actual del puntero y los almacena en el buffer binario obj en la
posición pos_inic.
431
Página
Prácticas de Empresa 2001/02 1er Turno
Página 94
Manual de referencia de Rembo-C
Nombre
FileWrite
Prototipo
int FileWrite ( var fich, var obj, int pos_inic, int long );
Descripción
Página
Escribe long bytes en el fichero indicado por el descriptor de fichero fich a
partir de la posición actual del puntero, leyéndolos del buffer binario obj a
partir de la posición pos_inic.
432
Nombre
FileClose
Prototipo
void FileClose ( var fich );
Descripción
Página
Cierra el fichero indicado.
439
3.7.- Interfaz de usuario
Nombre
OpenWindow
Prototipo
var OpenWindow ( str win, int izq, int arr, int der, int abajo );
Descripción
Página
Abre una nueva ventana con las coordenadas de las esquinas indicadas en
% con respecto al tamaño de la ventana. Le asocia el nombre indicado con
win.
440
Nombre
HideWindow / ShowWIndow / CloseWindow
Prototipo
void HideWindow / ShowWindow / CloseWindow ( str win );
Descripción
Página
Oculta / Muestra / Cierra la ventana indicada por win.
444 / 445 /446
3.8.- Primitivas relacionadas con la evaluación
Nombre
Exec
Prototipo
int Exec ( str rbxpath );
Descripción
Carga y ejecuta el script de Rembo-C del fichero indicado por rbxpath en un
nuevo hilo. Devuelve el identificador del nuevo hilo.
464
Página
Prácticas de Empresa 2001/02 1er Turno
Página 95
Manual de referencia de Rembo-C
Nombre
Eval
Prototipo
int Exec ( str expresion );
Descripción
Página
Evalúa una expresión de Rembo-C en un nuevo hilo y devuelve su
identificador asociado.
465
Nombre
KillThread
Prototipo
void KillThread ( int IDThread );
Descripción
Página
Elimina el hilo identificado por IDThread.
467
Nombre
RaiseError
Prototipo
void RaiseError ( int errno, str mensaje );
Descripción
Eleva una excepción. Ver págs. 468 / 469 / 470 y 471 para más detalles
sobre las excepciones existentes.
468
Página
3.9.- Variables persistentes
Nombre
Export
Prototipo
void Export ( var cont, str nombre, str rango );
Descripción
Página
Declara una variable de nombre nombre y contenido cont que permanece en
el sistema aunque se reinicie ( persistente ). El ámbito viene indicado por
rango.
476
Nombre
UnExport
Prototipo
void UnExport ( str nombre, str rango );
Descripción
Elimina la declaración de la variable persistente de nombre nombre del
ámbito indicado por rango.
478
Página
3.10.- Primitivas relacionadas con la red
Nombre
SysLog
Prototipo
void SysLog ( str mensaje );
Descripción
Página
Manda un mensaje al fichero de log del servidor
485
Prácticas de Empresa 2001/02 1er Turno
Página 96
Manual de referencia de Rembo-C
3.11.- Primitivas del sistema
Nombre
ShowConsole / HideConsole
Prototipo
void ShowConsole / HideConsole (void );
Descripción
Página
Muestra / Oculta la ventana de errores de Rembo
500 / 501
Nombre
Print / Printf
Prototipo
Descripción
Página
Muestran mensajes en la ventana. Se usan para depuración.
502 / 503
Nombre
Keyb
Prototipo
void Keyb ( str pais );
Descripción
Página
Carga el mapa de tecla del país indicado. El valor por defecto es us (
Estados Unidos ). El valor para el teclado español es es.
507
Nombre
CodePage
Prototipo
void CodePage ( int IdPágina);
Descripción
Carga la página de códigos indicada por IdPágina. El valor por defecto es
437 ( IBM PC-8 ). El usual es 850 IBM Latin I.
509
Página
Prácticas de Empresa 2001/02 1er Turno
Página 97
ANEXO A : GUÍA RÁPIDA DE
INSTALACIÓN DE REMBO
GUÍA RÁPIDA DE INSTALACIÓN DE REMBO
1.- Consideraciones previas
Nota : Esta guía rápida de instalación de Rembo recoge los pasos básicos necesarios para
que ponga a funcionar un servidor Rembo en su máquina. Tenga en cuenta que no resuelve
las posibles dudas planteadas, en cuyo caso debe dirigirse al manual de usuario.
Se van a instalar 3 sistemas operativos en una misma máquina que serán gestionados por el
gestor de arranque remoto REMBO. Los sistemas operativos en cuestión son:
•
•
•
Windows 2000 Profesional.
Windows 98 SE.
Linux Redhat 7.1.
La máquina servidora es un PC con el sistema Linux instalado. El REMBO se instalará bajo
dicho sistema operativo. Esta misma máquina proveerá todos los servicios característicos de
un servidor (DHCP, TFTP, SAMBA, etc) si bien tan solo DHCP será imprescindible para
proveer el arranque remoto. Vamos a omitir los pasos de instalación de dichos servicios
suponiendo que ya los ha instalado (en caso contrario consultar manuales) para centrarnos en
el propio REMBO. En nuestro caso se ha instalado REMBO por encima de una máquina que ya
suministraba arranque remoto a través de BpBatch. La máquina no genera ningún conflicto ya
que éste gestor puede ser sustituido por Rembo sin ninguna dificultad ni problemas añadidos.
Advertencia : el servicio TFTP debe ser desactivado ya que entrará en conflicto con Rembo
por la utilización de un puerto udp. Hágalo antes de instalar Rembo.
2.- Instalando REMBO
Elija el directorio donde quiera instalar el servidor REMBO bajo Unix / Linux. En nuestro caso
por ejemplo se ha utilizado usr/local/rembo. Extraiga en dicho directorio el contenido del
paquete REMBO y debería ver lo siguiente:
•
•
•
•
Un programa llamado rembo (el servidor).
Un fichero de texto llamado rembo.conf (el fichero de configuración del servidor).
Un fichero de texto llamado srvfiles.nc (el paquete de ficheros básico del servidor).
Un subdirectorio llamado misc, con varios ficheros que puede necesitar más adelante.
Edite el contenido del fichero rembo.conf indicando al menos el directorio base de instalación
de Rembo (Basedir) y el password que utilizará (NetPassword).
El fichero de texto srvfiles.nc contiene un conjunto mínimo de ficheros que REMBO necesita
para arrancar. Llegado a este punto deberá arrancar Rembo por primera vez. Arranque el
servidor escribiendo rembo –d –v 4 en la línea de comandos. Durante esta primera ejecución
tardará un poco más de tiempo para generar una clave criptográfica aleatoria.
Con el servidor en ejecución edite el fichero srvfiles.nc y sustituya la línea open 127.0.0.1
install con open 127.0.0.1 xxxx donde xxxx es la clave que ha utilizado como NetPassword en
el fichero rembo.conf.
Ya puede ejecutar el comando misc/netclnt srvfiles.nc en el directorio de instalación del
servidor. Se transferirán varios ficheros al servidor y NetClnt volverá a la línea de comandos
después de transferir el último fichero.
Su servidor Rembo ya está instalado y listo para recibir peticiones de arranque remoto.
Prácticas de Empresa 2001/02 1er Turno
Página 100
3.- Instalando los Sistemas Operativos.
Las operaciones de instalación de los sistemas operativos se efectuarán desde una máquina
cliente con opciones de administración. En ella, se ejecutarán tanto el Wizard como los scripts
necesarios para generar las imágenes que serán transferidas al sistema servidor.
Es recomendable instalar cualquier sistema operativo en un ordenador totalmente limpio, y
hacer la imagen desde éste. Asimismo utilice otro equipo diferente para restaurar las imágenes
durante las pruebas, ya que si algo falló al hacer la imagen siempre tendrá oportunidad de
repetir la operación sin tener que reinstalar el sistema.
Para la instalación final le recomendamos los siguientes parámetros:
•
•
•
•
Partición 1:Primaria:NTFS => Windows 2000 Profesional.
Partición 2:Primaria:FAT32 => Windows 98 SE.
Partición 5:Lógica:LinuxExt2 => Linux Redhat 7.1.
Partición 6:Lógica:LinuxSwap => LinuxSwap para la Redhat.
En primer lugar, no ocupe más particiones primarias de las necesarias. Dado que linux puede
instalarse en una partición lógica es recomendable hacerlo así. Asimismo tenga en cuenta un
pequeño conflicto existente entre Windows 2000 y 98, que no permitirá al Windows 2000
arrancar correctamente si no ocupa la primera partición, en lugar del Windows 98.
4.- Clonando Windows 2000
Normalmente las operaciones de clonado de los sistemas operativos se hacen sin problemas
desde el Wizard siempre que respete las peculiaridades de cada sistema. En concreto
Windows 2000 tiene un detalle que no podemos pasar por alto. La carpeta dllcache está
comprimida, y Rembo no puede trabajar con carpetas ya comprimidas en el momento de
restaurar un sistema. Por ello, siga los siguientes pasos para clonar Windows 2000:
1. Instale Windows 2000 en un ordenador limpio.
2. Descomprima la carpeta WINNT/System32/dllcache.
3. Haga la imagen de este sistema y transfiérala al servidor con el Wizard.
Asimismo Windows 2000 tiene otra peculiaridad: instale el SO en una partición del mismo
tamaño que tendrá en el equipo final. Cualquier cambio en el tamaño de la partición hará que
Windows 2000 lo detecte como cambio de hardware y siempre arrancará el asistente de
hardware después de cada restauración.
No existen más consideraciones particulares.
5.- Restaurando y arrancando Windows 2000
La función NetInfo resulta de gran utilidad para obtener información de la máquina cliente.
Podemos obtener su dirección IP, MAC, etc. Esto permitirá personalizar los datos de cada
máquina después del arranque. En Windows 2000 hemos integrado en la página del menú un
pequeño script que realiza esta función, y el parcheo se efectúa tal que:
var ip=StrParse(NetInfo.IPAddress,".");
str nombre="pem"+ip[3];
NTChangeName(nombre);
Se captura el último número de la IP de la máquina y se almacena. La función
NTChangeName cambia integralmente el nombre de la máquina (su nombre de red,
hostname, netbios...). Puede verse el script completo en la página del menú.
Prácticas de Empresa 2001/02 1er Turno
Página 101
El arranque de Windows 2000 se efectúa con un simple HDBoot(0,1); en nuestro caso, disco
0, partición 1.
6.- Clonando Windows 98 SE
El Windows 98 SE resulta más permisivo que el Windows 2000 para clonarse. Siga los
siguientes pasos:
1. Instale Windows 98 SE en un ordenador limpio.
2. Cree en el directorio raíz un fichero c:\rembo.bat. (éste será el encargado del parcheo
del nombre y podrá ser modificado en tiempo de arranque).
3. Añada una línea call rembo al autoexec.bat de modo que se ejecute en el arranque.
Este fichero rembo.bat será el que podrá personalizar según sus necesidades. En nuestro
caso se utilizará para parchear el nombre de cada máquina. Al contrario que Windows 2000, el
98SE no tendrá restricciones con el tamaño de la partición y podrá instalarse en una partición
que no tiene por qué coincidir con la final.
7.- Restaurando y arrancando Windows 98 SE
Se deberá crear un script de restauración que contenga el parcheo del nombre. En nuestro
menú de arranque puede verse el proceso, básicamente tomados del manual puntos 4.2.3 y
4.2.4. Veamos un fragmento del mismo.
var ipa = StrParse(NetInfo.IPAddress,".");
Hostname = "pem"+ipa[3];
PatchFile("cache://global/rembo.reg","disk://0:2/rembo.reg");
CreateTextFile("disk://0:2/rembo.bat",
"c:\\windows\\regedit"
" /L:c:\\windows\\system.dat"
" /R:c:\\windows\\user.dat"
" c:\\rembo.reg");
Como vemos se captura de nuevo la IP y comprobamos sus parámetros para parchear el
nombre de la máquina. Puede hacerse usando el propio regedit o a través de la función
PatchFile. Después de muchas pruebas el sistema de regedit es más fiable y hemos optado
por él tras llegar a una conclusión muy simple: regedit es un programa de 120Kb, portable en
cualquier disquette o fácilmente descargable de internet. Borrarlo o cualquier actividad similar
no supone ninguna restricción para su uso por su fácil disponibilidad.
El contenido de rembo.reg puede verlo en el apartado 4.2.4 del manual. Básicamente
consiste en cambiar los parámetros del nombre de la máquina parcheando el registro.
El arranque de Windows 98 SE se efectúa con un simple HDBoot(0,2); en nuestro caso, disco
0, partición 2.
Prácticas de Empresa 2001/02 1er Turno
Página 102
9.- Clonando Linux
El clonado de Linux se efectúa sin problemas, siguiendo los siguientes pasos:
1. Instale Linux en una máquina limpia.
2. Transfiera la imagen al servidor.
3. Transfiera el kernell al directorio donde ubica la imagen de linux, ya que le hará falta
para arrancar.
4. Transfiera el fichero etc/fstab donde ubica la imagen de linux para poder modificarlo
durante el arranque.
Puede instalarse en cualquier partición ya que posteriormente se podrá modificar el fstab
para reubicar el arranque de la máquina.
10.- Restaurando y arrancando Linux
En la restauración edite el fichero local fstab para ubicar las particiones de arranque y swap
según su conveniencia. En nuestro caso lo hemos probado indistintamente en 3-4 y en 5-6, sin
haber producido problemas. Veamos un fragmento:
RestoreDiskImage(0,3,"cache://global/hdimages/linux/linuxbase.base");
CopyFile("net://global/hdimages/linux/linuxbase.fstab",
"disk://0:3/etc/fstab");
Como puede verse no es más que transferir el fstab adecuado. Puede ver el script completo
en nuestro menú.
En el arranque de Linux deberemos especificarle dónde está ubicado el kernell. En nuestro
caso puede arrancarse con la orden:
LXBoot("cache://global/hdimages/linux/linuxbase.krn","","root=/dev/hda5");
Como puede verse es el único que no utiliza el HDBoot estándar.
•
•
•
En estas circunstancias, posee usted un sistema con Rembo instalado y preparado
para arrancar los 3 sistemas operativos mencionados.
Puede utilizar las claves del propio Linux (a través del samba o el fichero de claves)
para autentificar usuarios en el arranque de rembo. Edite el fichero rembo.conf según
lo especificado en el manual para los dominios de autentificación.
Es conveniente proteger el acceso al menú de inicio del Wizard. Vea el script de
ejemplo para más información.
Prácticas de Empresa 2001/02 1er Turno
Página 103
ANEXO B : OTROS ASPECTOS DE
REMBO
Otros aspectos de Rembo
CAPÍTULO 1 : PERSONALIZANDO REMBO
1.1.- Menú personalizado
Para crear un menú personalizado podemos partir de la siguiente estructura:
OpenMenu("nombre", 30, 30,
"<title>Mi cabecera</title>"
"<style>B {font-weight: normal; color: red}</style>"
"<base href='cache://global/images'>",
{{"<br><br><b>titulo1</b>","miicono1.pcx","MiFuncion1();"},
{"<br><br><b>titulo2</b>","miicono2.pcx","MiFuncion2();"},
........................................................
{"<br><br><b>titulon</b>","miiconoN.pcx","MiFuncionn();"}
});
Para cada una de las opciones que queremos que aparezca colocamos una nueva rama con
el título que queremos que muestre, el icono, y la función que se ejecutará si se selecciona la
opción.
1.2.- Modificar el menú raíz
Si queremos modificar las opciones que aparecen en la esquina inferior derecha de nuestra
pantalla de Rembo basta con ejecutar la siguiente función en nuestra página de inicio :
SaveText(<html>
<select menu style="color: navy;">
<option onmouseup="Mifuncion1();">Mimensaje1...
<option onmouseup="Mifuncion2();">Mimensaje2...
............................................
<option onmouseup="MifuncionN();">MimensajeN
</select>
</html>,"display://root/menu/SELF");
En donde para cada rama le indicamos que función queremos llamar y que mensaje
aparecerá el menú
Si lo que queremos es que no aparezca nada, pues nada, no le indicamos ninguna rama y ya
está. Quedaría entonces como sigue :
SaveText(<html>
<select menu style="color: navy;">
</select>
</html>,"display://root/menu/SELF");
De este modo al pulsar la tecla inicio de Windows no nos aparece nada en el menú
desplegable.
Nota : Parece que no es posible eliminar este menú completamente, puesto que es parte del
copyright de Rembo.
Prácticas de Empresa 2001/02 1er Turno
Página 106
Otros aspectos de Rembo
1.3.- Rembo en castellano
Es posible añadir un nuevo nivel de personalización a Rembo : cambiar todos los mensajes
que muestra al castellano.
Para ello tenemos que utilizar unos archivos que aparecen en el directorio SDK/samples del
directorio de Rembo. En este directorio tenemos una serie de archivos con extensión .rbc, que
son los fuentes sin compilar.
Si editamos el contenido de cada uno de ellos, podemos cambiar los mensajes, menús,
cabeceras, etc., de nuestro programa del inglés al español, o incluso modificarlos según
nuestras necesidades.
Una vez modificados, basta con compilarlos con el programa rbcc que está en el directorio
SDK, obteniendo así los ficheros con extensión .rbx. Estos ficheros hay que subirlos al servidor
al directorio plugins. Una vez hecho esto ya podemos disfrutar de nuestro querido Rembo en
castellano.
1.4.- Cambio pantalla de autentificación
La personalización de la pantalla de autentificación de Rembo no es un proceso muy
complicado.
Si partimos de la pantalla original de Rembo ( ver utils.rbc en el directorio /SDK/samples ) es
fácil modificarla para adaptarla a nuestras necesidades: con un poco de imaginación y algo de
conocimientos sobre HTML podremos tener una nueva pantalla de autentificación.
Como ejemplo mostramos una realizada por nosotros :
/* Código para cambiar la pantalla de autentificación de usuario */
bool Autentificar(void)
{
if (Offline())
{
Log("Modo
sin
red:
ignorando
peticion
autentificacion<br>");
return false;
}
// Ventana de autentificaci½n
// Siempre arriba, no se puede mover ni redimensionar
var win = OpenWindow("authwin",20,20,80,60);
win.alwaysOnTop = true;
win.movable = false;
win.resizable = false;
de
LogonCanceled = true; // Si se cierra la ventana, se cancela la
// autentificación
SaveText("<title>Escuela
Técnica
Superior
de
Informática</title>"
"<table>"
"<td text=navy face='sans-serif'>"
Ingeniería
en
"<tr><td><tr><td><td><br><br>  Usuario: "
"<td><br><br><input name=username size=16>"
"<tr><td><tr><td><td>  Password: "
"<td><input name=password size=16 "
"type=password
onsubmit='TryLogon(username,password);'>"
"<tr><td><tr><td><td colspan=2 text=blue>"
"<tr><td><td colspan=2><br><center>"
"<button onmouseup='TryLogon(username,password);'>"
" Aceptar </button> "
Prácticas de Empresa 2001/02 1er Turno
Página 107
Otros aspectos de Rembo
"<button onmouseup='CloseWindow(\"authwin\");'>"
" Cancelar </button>"
"</center></table>",
"display://authwin/SELF");
// Esto es para hacer que la ventana se ajuste al contenido
// Pero solo al que hay dentro, y no al titulo :(
// AutoResizeWindow("authwin",true,true);
// Wait for the window to close
while(FileExists("display://authwin"))
delay(20);
return AuthInfo.Success && !LogonCanceled;
}
Con este código creamos una pantalla de autentificación que no se puede mover ni
redimensionar.
1.5.- Ejecución de scripts
Si queremos utilizar funciones en nuestra página de inicio que aparezcan en un módulo de
librería externo ( ficheros .rbx ) debemos ejecutar el siguiente comando :
join(Exec("plugins/micodigo.rbx"));
De esta forma no es necesario tener nuestra página de inicio repleta de funciones o código.
Este comando es posible utilizarlo también dentro de nuestro propios scripts.
1.6.- Instalación asistentes avanzados
Por defecto, las versiones Empresa y Campus utilizan los asistentes básicos que se incluyen
en la versión Profesional. Es necesario activarlos para poder utilizarlos.
El proceso es el siguiente :
•
•
•
•
Compilar los scripts advwiz.rbc y advforms.rbc situados en el directorio
misc/SDK/samples.
Mediante la sconsole cargar los ficheros compilados .rbx en el directorio files/plugins/
del servidor Rembo.
Descargar
el
archivo
enterpr.zip
de
la
dirección
https://rembo.com/secure/public/enterpr.zip.
Descomprimir el archivo y cargar los 3 ficheros obtenidos al servidor Rembo :
•
•
Menu.seq y rembo.shtml al directorio files/.
Enterprise.pcxs al directorio files/images/.
Prácticas de Empresa 2001/02 1er Turno
Página 108
Otros aspectos de Rembo
CAPÍTULO 2 : ALGUNAS CUESTIONES DE SEGURIDAD
2.1.- Proceso de autentificación
En nuestra página de inicio personalizada tratamos el proceso de autentificación de la
siguiente forma :
•
•
•
•
•
Mostramos la pantalla de autentificación personalizada.
Solicitamos al usuario que se identifique. A partir de aquí tenemos 3 posibilidades :
Si el usuario se identifica adecuadamente mostramos el menú principal.
Si la contraseña es incorrecta borramos la contraseña introducida y esperamos que la
vuelva a introducir.
Si el usuario cancela la autentificación, ya sea cerrando la ventana o pulsando el botón
Cancelar, le mostramos un mensaje indicando que el nombre de usuario o la contraseña
son incorrectos y le volvemos a mostrar la pantalla de autentificación.
Los nombres de usuario y password los hemos tomado de la máquina Linux que actúa como
servidora. Es posible también que la autentificación se realice mediante dominio NT o Radius (
ver Manual del Servidor de Rembo para más detalles ).
Como ejemplo mostramos el código que hemos utilizado en nuestra página de inicio
personalizada:
bool aut = false;
while (!aut)
{
aut = Autentificar();
if(!aut)
{
OpenMessage("auten","Nombre de usuario o contraseña incorrectos");
delay(300);
CloseWindow("auten");
}
}
2.2.- Asegurar arranque en Rembo
Para evitar que un usuario se salte el arranque en red usando la tecla escape cuando se
inicia el ordenador podemos utilizar una opción que nos da Rembo.
Consiste en borrar la bandera de partición activa de todas las particiones, de modo que
cuando un usuario se quiera saltar el arranque en red para arrancar el disco local directamente
le salte un mensaje de aviso y el ordenador se quede bloqueado.
El fragmento de código que realiza esta operación es el siguiente :
OpenMessage("limphd","Limpiando MBR ...");
delay(200);
CloseWindow("limphd");
SaveText("Solo se puede arrancar en red, pillín :D",
"disk://0:0/BootMessage");
HDClean(0,0);
SetBootablePartition(0,0);
Prácticas de Empresa 2001/02 1er Turno
Página 109
Otros aspectos de Rembo
Este script se puede ejecutar al crear toda la estructura de particiones del disco duro y de esta
forma se evita el uso del equipo si no se ha autentificado previamente.
Nota : Es evidente que si por cualquier motivo la red o el servidor de autentificación deja de
funcionar el ordenador queda totalmente inutilizado.
2.3.- Bloqueo de periféricos
Se pueden definir para cada grupo un bloqueo de una serie de periféricos mediante la función
Lockout.
Esta función nos permite bloquear lo siguiente:
1.
2.
3.
4.
5.
6.
Ratón
Teclado
Reset
Power off
Pantalla
Todo
->
->
->
->
->
->
Lockout
Lockout
Lockout
Lockout
Lockout
Lockout
mouse
keys
reset
poweroff
screen
all
Este bloqueo se mantiene mientras Rembo esté activo, y se desbloquean al darle el control al
sistema operativo con HDBoot, LXBoot, RDBoot o DeviceBoot.
El bloqueo se ejecuta para todos los hosts pertenecientes al grupo.
Otra posibilidad es usar en los scripts las funciones LockKeyboard, LockMouse o
LockScreen, que permite bloquear el teclado, el ratón o la pantalla del ordenador local. Esta
opción es la que hemos utilizado para evitar que el usuario toque nada mientras se restaura un
sistema operativo.
Prácticas de Empresa 2001/02 1er Turno
Página 110
ANEXO C : MENÚ DE EJEMPLO
Menú de ejemplo
MENÚ DE EJEMPLO
Para terminar este documento, queremos mostrar un ejemplo de página de inicio que hemos
creado para usarla durante las prácticas. Puede servir de base para su propia página si así lo
desea. Con un poco de imaginación y algo de conocimientos de programación (sobre todo,
HTML) es posible conseguir algunas cosas sorprendentes.
Ejemplo : practicas.shtml
<!-- prueba1.shtml - Probando Scripts de Rembo...
--->
<script type="text/rembo-c">
// Compatibilidad con versiones anteriores a la 0.99.
if(FileExists("cache://global/plugins/rembo099.rbx"))
{
join(Exec("plugins/rembo099.rbx"));
}
// Cargando utils.rbx
if(FileExists("cache://global/plugins/utils.rbx"))
{
join(Exec("plugins/utils.rbx"));
}
// Para declarar los modos por defecto
str DefVideoMode;
str DefKeyMap;
str DefCodeMap;
// Para parchear W98
str Hostname;
var BasicErrorHandler(var exc) { return exc; }
with(BasicErrorHandler) try
{
// Obligamos modo 800x600 y teclado en espaÏol
Settings.VideoMode = "800x600";
Keyb("es");
if(DefCodeMap != "")
CodePage((int)DefCodeMap);
}
/* C½digo para cambiar la pantalla de autentificaci½n de usuario */
bool Autentificar(void)
{
if (Offline())
{
Log("Modo sin red: ignorando peticion de
autentificacion<br>");
return false;
}
// Ventana de autentificaci½n
// Siempre arriba, no se puede mover ni redimensionar
var win = OpenWindow("authwin",20,20,80,60);
win.alwaysOnTop = true;
win.movable = false;
win.resizable = false;
LogonCanceled = true; // Si se cierra la ventana,
//se cancela la autentificaci½n
SaveText("<title>Escuela Técnica Superior de Ingeniería en
Informática</title>"
"<table>"
"<td text=navy face='sans-serif'>"
"<tr><td><tr><td><td><br><br>  Usuario: "
"<td><br><br><input name=username size=16>"
Prácticas de Empresa 2001/02 1er Turno
Página 112
Menú de ejemplo
“<tr><td><tr><td><td>  Password: "
“<td><input name=password size=16 "
"type=password onsubmit='TryLogon(username,password);'>"
"<tr><td><tr><td><td colspan=2 text=blue>"
"<tr><td><td colspan=2><br><center>"
"<button onmouseup='TryLogon(username,password);'>"
" Aceptar </button> "
"<button onmouseup='CloseWindow(\"authwin\");'>"
" Cancelar </button>"
“</center></table>",
“display://authwin/SELF");
// Esto es para hacer que la ventana se ajuste al contenido
// Pero solo al que hay dentro, y no al titulo :(
// AutoResizeWindow("authwin",true,true);
// Wait for the window to close
while(FileExists("display://authwin"))
delay(20);
return AuthInfo.Success && !LogonCanceled;
}
void LimpiarHD (void)
{
/* Las particiones que vamos a utilizar son las siguientes :
* Partici½n 1:
* Partici½n 2:
* Partici½n 3:
* Partici½n 4:
* Libres para cach_
*/
NTFS
FAT32
EXT2
LINUX-SWAP
:
1 Gb
500 Mb
1,5 Gb
256 Mb
+900 Mb
HideWindow("Menuppal");
OpenMessage("limphd","Limpiando HD ...");
delay(200);
CloseWindow("limphd");
SetPrimaryPartitions(0, "NTFS:1000000 FAT32:500000 EXT2:1500000
LINUX-SWAP:256000");
HDClean(0,1);
HDClean(0,2);
HDClean(0,3);
HDClean(0,4);
// Lo siguiente es para impedir que se salten el arranque remoto
// dandole al escape
OpenMessage("limphd","Limpiando MBR ...");
delay(200);
CloseWindow("limphd");
SaveText("Solo se puede arrancar en red:D",
"disk://0:0/BootMessage");
HDClean(0,0);
SetBootablePartition(0,0);
OpenMessage("finlimphd","Fin de limpieza");
delay(300);
CloseWindow("finlimphd");
ShowWindow("Menuppal");
}
void ArrancarW2K (void)
{
CloseWindow("Menuppal");
OpenMessage("aw2k","Arrancando Windows 2000 ...");
delay(300);
CloseWindow("aw2k");
HDBoot(0,1);
}
Prácticas de Empresa 2001/02 1er Turno
Página 113
Menú de ejemplo
void ArrancarW98 (void)
{
CloseWindow("Menuppal");
OpenMessage("aw98","Arrancando Windows 98 SE ...");
delay(300);
CloseWindow("aw98");
HDBoot(0,2);
}
void ArrancarLinux (void)
{
CloseWindow("Menuppal");
OpenMessage("alinux","Arrancando Linux Red Hat 7.1 ...");
delay(300);
CloseWindow("alinux");
LXBoot("cache://global/hdimages/linux/linuxbase.krn","",
"root=/dev/hda3");
}
void RestaurarW2K (void)
{
HideWindow("Menuppal");
LockKeyboard(true);
LockMouse(true);
OpenMessage("rw2k","Restaurando Windows 2000 ...");
delay(300);
CloseWindow("rw2k");
//HDClean(0,1);
//RestoreDiskImage(0,1,
//
"cache://global/hdimages/winnt/win2000base.img");
Synchronize("cache://global/hdimages/win9x/win2000base.img",
"disk://0:1","b");
var ip=StrParse(NetInfo.IPAddress,".");
str nombre="pem"+ip[3];
NTChangeName(nombre);
OpenMessage("finrw2k","Fin de la restauración");
delay(300);
CloseWindow("finrw2k");
LockMouse(false);
LockKeyboard(false);
ShowWindow("Menuppal");
}
void RestaurarW98 (void)
{
HideWindow("Menuppal");
LockKeyboard(true);
LockMouse(true);
OpenMessage("rw98","Restaurando Windows 98 SE ...");
delay(300);
CloseWindow("rw98");
//HDClean(0,2);
//RestoreDiskImage(0,2,
//
"cache://global/hdimages/win9x/win98se.img");
Synchronize("cache://global/hdimages/win9x/win98se.img",
"disk://0:2","b");
Prácticas de Empresa 2001/02 1er Turno
Página 114
Menú de ejemplo
var ipa = StrParse(NetInfo.IPAddress,".");
Hostname = "pem"+ipa[3];
PatchFile("cache://global/rembo.reg","disk://0:2/rembo.reg");
CreateTextFile("disk://0:2/rembo.bat",
"c:\\windows\\regedit"
" /L:c:\\windows\\system.dat"
" /R:c:\\windows\\user.dat"
" c:\\rembo.reg");
OpenMessage("finrw98","Fin de la restauración");
delay(300);
CloseWindow("finrw98");
LockMouse(false);
LockKeyboard(false);
ShowWindow("Menuppal");
}
void RestaurarLinux (void)
{
HideWindow("Menuppal");
LockKeyboard(true);
LockMouse(true);
OpenMessage("rlinux","Restaurando Linux Red Hat 7.1 ...");
delay(300);
CloseWindow("rlinux");
HDClean(0,3);
RestoreDiskImage(0,3,
"cache://global/hdimages/linux/linuxbase.base");
CopyFile("net://global/hdimages/linux/linuxbase.fstab",
"disk://0:3/etc/fstab");
OpenMessage("finrlinux","Fin de la restauración");
delay(300);
CloseWindow("finrlinux");
LockMouse(false);
LockKeyboard(false);
ShowWindow("Menuppal");
}
var w = Window("root");
//
//
//
//
Para eliminar el menœ del Rembo que sale como el de inicio de
Windows. Parece que no puede eliminarse debido al copyright (es su
identificaci½n)
Pero si que se puede dejar sin entradas :D.
SaveText(<html>
<select menu style="color: navy;">
</select>
</html>,"display://root/menu/SELF");
// Para indicar el color de fondo
w.widgets.color="#CCCC99";
// Y, por último, los menús
Prácticas de Empresa 2001/02 1er Turno
Página 115
Menú de ejemplo
// Primero hay que autentificar
bool aut = false;
while (!aut)
{
aut = Autentificar();
if(!aut)
{
OpenMessage("auten",
"Nombre de usuario o contraseña incorrectos");
delay(300);
CloseWindow("auten");
}
}
// Y después nos sale ya el menú de arranque
OpenMenu("Menuppal", 30, 30,
"<title>Menu principal</title>"
"<style>B {font-weight: normal; color: red}</style>"
"<base href='cache://global/images'>",
{{"<br><br><b>Volver a autentificar</b>","zergface.pcx","Autentificar();"},
{"<br><br><b>Dejar limpito el HD</b>","cnf-overlord.pcx","LimpiarHD();"},
{"<br><br>Arrancar <b>Windows2000</b>","cnf-nexo.pcx","ArrancarW2K();"},
{"<br><br>Arrancar <b>Windows98SE</b>","cnf-crucero.pcx","ArrancarW98();"},
{“<br>Arrancar <b>Linux Red Hat 7.1</b>","over.pcx","ArrancarLinux();"},
{"<br><br>Restaurar <b>Windows2000</b>","cnf-nexo.pcx","RestaurarW2K();"},
{"<br><br>Restaurar <b>Windows98SE</b>","cnf-crucero.pcx","RestaurarW98();"},
{"<br><br>Restaurar <b>Linux Red Hat 7.1</b>","over.pcx","RestaurarLinux();"}
});
</script>
<body>
</body>
Prácticas de Empresa 2001/02 1er Turno
Página 116