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 # 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 # 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 world”); 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 , 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
”);

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
”);

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 , 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 …
”); // 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
”);

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 ...
”); // 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 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 . En llamadas a manejadores de eventos.

Para que un script sea ejecutado por REMBO es necesario declararlo de tipo text/rembo-c, como sigue: código del 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 Elimina la definición de una variable global.

•

#pragma clear Resetea el contenido de la variable a NIL. Útil para las variables protegidas.

•

#pragma protect 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, "Mi cabecera" "B {font-weight: normal; color: red}" "", {{"

titulo1","miicono1.pcx","MiFuncion1();"}, {"

titulo2","miicono2.pcx","MiFuncion2();"}, ........................................................ {"

titulon","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( Mimensaje1... Mimensaje2... ............................................ MimensajeN ,"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( ,"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
"); 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("Escuela Técnica Superior de Informática" "" "

" Ingeniería en "
	Usuario: " "	" "
	Password: " "	" "
	" "
	" "" " Aceptar  " Prácticas de Empresa 2001/02 1er Turno Página 107 Otros aspectos de Rembo "" " Cancelar " "

", "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 // 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
"); 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("Escuela Técnica Superior de Ingeniería en Informática" "" "

" "
	Usuario: " "	" Prácticas de Empresa 2001/02 1er Turno Página 112 Menú de ejemplo “
	Password: " “	" "
	" "
	" "" " Aceptar  " "" " Cancelar " “

", “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( ,"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, "Menu principal" "B {font-weight: normal; color: red}" "", {{"

Volver a autentificar","zergface.pcx","Autentificar();"}, {"

Dejar limpito el HD","cnf-overlord.pcx","LimpiarHD();"}, {"

Arrancar Windows2000","cnf-nexo.pcx","ArrancarW2K();"}, {"

Arrancar Windows98SE","cnf-crucero.pcx","ArrancarW98();"}, {“
Arrancar Linux Red Hat 7.1","over.pcx","ArrancarLinux();"}, {"

Restaurar Windows2000","cnf-nexo.pcx","RestaurarW2K();"}, {"

Restaurar Windows98SE","cnf-crucero.pcx","RestaurarW98();"}, {"

Restaurar Linux Red Hat 7.1","over.pcx","RestaurarLinux();"} });

Prácticas de Empresa 2001/02 1er Turno

Página 116