VISITAS:

viernes, 6 de septiembre de 2013

Solaris packages

¿Qué son packages Solaris?

Conceptos y definiciones previas:
  • En Solaris, el software de aplicación se entrega en forma de packages.
  • Un package es una colección de ficheros y directorios.
  • El package lo construye el desarrollador del software.
  • Un producto software se distribuye en uno o más packages.
  • Los packages software los instala el administrador de la máquina.

Componentes de un paquete

Un paquete se compone de: 
  • Package objects: son los ficheros que componen la aplicación
  • Control files: controlan dónde, cómo y si el paquete se instala. Se clasifican en:
    • information files
    • installation scripts
Para empaquetar una aplicación se tienen que seguir los siguientes pasos:
  1. crear los ficheros necesarios: package objects (ficheros y directorios de la aplicación), ficheros prototype y pkginfo (obligatorios), otros ficheros opcionales, scripts de instalación (opcionales)
  2. construir el paquete con el comando pkgmk
El fichero pkginfo es un fichero obligatorio que define los parámetros del package: abreviatura del package, nombre completo, arquitectura, etc.
El fichero prototype es un fichero obligatorio que lista los componentes del package. Hay una entrada por cada package object, information file e installation script. Cada entrada consta de varios campos que describen el componente: localización, atributos y tipo de fichero.
El fichero compver es un fichero opcional que define versiones previas del package que son compatibles con la versión de este package.
El fichero depend es un fichero opcional que indica otros packages necesarios para instalar este package.
El fichero space define los requerimientos de espacio en disco para el package, además de los necesarios por los package objects.
El fichero copyright es un fichero opcional que define un mensaje de copyright que saldrá cuando se instale el package.
Los installation scripts no son obligatorios. Sirven para ejecutar acciones durante la instalación del package. Tienen las siguientes características:

  • Se componen de comandos bourne shell.
  • Los permisos del script deben ser 0644
  • El script no necesita el identificador de shell #!/bin/sh

Tipos de script de instalación:

  • request: pide información al usuario que está instalando el package
  • checkinstall: realiza verificaciones
  • procedure scripts: definen acciones que ocurren en puntos particulares de la instalación y desinstalación (preinstall, postinstall, preremove, postremove)
  • class action scripts: definen acciones a realizar sobre un grupo de objetos

Consideraciones antes de construir un package

Antes de construir un package hay que decidir si el producto consta de uno o de más packages. Cuando se decide hacer múltiples packages, hay que pensar en cómo segmentar la aplicación.
Consideraciones a tener en cuenta para decidir cómo segmentar la aplicación en packages:
  • todos los packages deben ser instalables remotamente
  • los packages deben instalarse en un file system concreto (/. /usr, etc) para soportar todas las configuraciones posibles de servidor.
  • los packages deben tener una funcionalidad claramente definida
  • los packages que requieran licencia deben ir separados
  • hay que evitar duplicidades y solapes en los ficheros/directorios de cada package

Comandos para construir packages

Crear un fichero prototipo que sirva de entrada a pkgmk: pkgproto
Crear un package instalable: pkgmk
Instalar un package: pkgadd
Almacenar respuestas a un request script: pkgask
Copiar packages en  un medio: pkgtrans
Desinstalar un package: pkgrm
Verificar la integridad de un package: pkgchk
Mostrar información sobre un package instalado: pkginfo
Mostrar los parámetros de un package instalado: pkgparam
Instalar un nuevo objeto en un package ya instalado: installf
Quitar un objeto de un package ya instalado: removef

Control Files

Package information files:
  • admin: administrative defaults file
  • compver: compatibility file
  • copyright: conpyright information file
  • depend: dependencies file
  • pkginfo: characteristics file
  • pkgmap: contents description file
  • prototype: information file
  • space: disk space requirements file
Optional installation scripts:
  • request: solicita información al usuario
  • checkinstall: chequea los requisitos de la instalación
  • preinstall: ejecuta acciones previas a la instalación
  • postinstall: ejecuta acciones posteriores a la instalación
  • preremove: ejecuta acciones previas a la desinstalación
  • postremove: ejecuta acciones posteriores a la desinstalación
  • class action: ejecuta acciones sobre un grupo específico de objetos

Construcción de un package

El proceso de construcción de un package

Los pasos típicos para la construcción de un package son (cuando se tiene experiencia se puede cambiar este orden):

  • Crear un fichero pkginfo para describir las características del package
  • Organizar el contenido del package en una estructura de directorios
  • Opcionalmente, crear ficheros de información: dependencias, copyright, de espacio en disco, etc.
  • Opcionalmente, crear scripts de instalación para customizar los procesos de instalación y desinstalación
  • Crear un fichero prototype
  • Construir el package con el comando pkgmk
  • Verificar el package comprobando que se instala bien
  • Distribuir el package

Variables de entorno

Las variables de entorno se pueden utilizar dentro de los ficheros pkginfo, prototype y en los ficheros de información.
Hay dos tipos de variables:
  • Variables de construcción: empiezan con una letra minúscula y se evalúan en tiempo de construcción del package (pkgmk)
  • Variables de instalación: empiezan con una letra mayúscula y se evalúan en tiempo de instalación (pkgadd)
Reglas generales sobre las variables de entorno:

  • En el fichero pkginfo, las definiciones de variables son de la forma PARAM=value, con la primera letra en mayúscula. Estas variables se evalúan sólo en tiempo de instalación (pkgadd)
  • En el fichero prototype, las definiciones de variables son de la forma !PARAM=value o $VAR=value, la primera letra puede ser mayúscula o minúscula. Sólo se evalúan las variables conocidas en tiempo de construcción

Fichero pkginfo

El  fichero pkginfo es un fichero ASCII que describe las características de un package junto a información que ayuda a controlar el flujo de la instalación.
Cada entrada en pkginfo es una línea que establece el valor de un parámetro de la forma:
PARAM = value
donde PARAM es uno de los parámetros estándar. El valor se puede poner entre comillas (simples o dobles) en caso de que se usen caracteres especiales de la shell.
Se pueden crear parámetros de usuario, los cuales deben empezar por mayúscula, indicando así que el parámetro se evaluará en tiempo de instalación.
Los siguientes parámetros son obligatorios en pkginfo:

  • PKG
  • NAME
  • ARCH
  • VERSION
  • CATEGORY

Además, pkgmk añade automáticamente los siguientes parámetros:

  • PATH
  • PKGINST
  • INSTDATE
Un mismo package puede tener diferentes versiones o ser compatible con distintas arquitecturas. Todas las variantes de un package se denominan package instances (determinadas por PKG, ARCH y VERSION).
El programa pkgadd asigna un identificador de package a cada instancia que se instala. Este identificador consiste en un nombre abreviado más un sufijo numérico. El identificador distingue una instancia de un package unívocamente en una máquina.

La abreviatura del package se define en el parámetro PKG de pkginfo. PKG tiene las siguientes características:

  • empieza por una letra y puede contener letras y números
  • el tamaño máximo es 32
  • habitualmente, los primero cuatro caracteres identifican a la compañía

El parámetro ARCH identifica la o las arquitecturas asociadas al package: ARCK=sparc
El parámetro VERSION identifica la versión del package. VERSION=release 1.0
El parámetro NAME especifica un nombre largo para el package (máximo 256 caracteres)
El parámetro CATEGORY especifica la categoría a la que pertenece el package: application o system.

Organización del contenido del package

Los objetos (ficheros) del package se organizan en una estructura de directorios que debería ser igual a la estructura que tendrán estos objetos en el sistema instalado. Esto ahorrará mucho tiempo y esfuerzo.
En primer lugar se crea un directorio para los objetos que componen el package (se recomienda que el nombre de este directorio coincida con el nombre abreviado PKG).
Después se organizan los objetos en una estructura de directorios igual a la del package ya instalado.

Fichero prototype

El fichero prototype contiene información sobre los objetos (ficheros, directorios) que componen el package.
Cada entrada de este fichero define un único objeto del package. Estas entradas tienen varios campos de información separados por espacios (en un orden especificado). Las líneas que empiezan por # se consideran comentarios y se ignoran.
Hay dos formas de crear un fichero prototype:
  • desde cero con un editor de texto
  • ayudado con el comando pkgproto
Los normal es utilizar la segunda opción para crear el fichero la primera vez y después editarlo con un editor de texto.
El comando pkgproto explora una estructura de directorios y ficheros, y genera un fichero pkgproto que luego se puede editar.

Formato de las entradas del fichero prototype:

  • part: (opcional) numérico, permite agrupar objetos en partes (por defecto, part=1)
  • ftype: un carácter, especifica el tipo de objeto
    • f = fichero ejecutable o de datos
    • e=fichero que se guarda previamente si existe
    • v=fichero volátil (ej. log)
    • d=directorio
    • x=directorio de acceso exclusivo a este package
    • l=link
    • p=named pipe
    • c=dispositivo de caracteres
    • b=dispositivo de bloques
    • i=fichero de información o script de instalación
    • s=link simbólico
  • class: es la clase de instalación para el objeto. Si no se especifica, se asume none.
  • path: path absoluto o relativo donde se instalará el objeto. Si el path es relativo, se usa el parámetro BASEDIR definido en el fichero pkginfo.
  • major: (opcional, utilizado en dispositivos)
  • minor: (opcional, utilizado en dispositivos)
  • mode: modo octal del objeto, por ej 0644 (permisos).
  • owner: propietario del objeto
  • group: grupo del objeto
Para crear un fichero prototype desde cero con pkgproto, cambiar al directorio anterior a donde se ha metido el contenido del package y ejecutar el comando pkgproto:

$ pkgproto ./pkg > ./pkg/package/prototype

Esto creará un fichero prototype con entradas como éstas:.

d none pkg/src 0755 jane staff
f none pkg/src/file.java 0555 jane staff
etc

Este fichero es útil para empezar, pero normalmente hay que editarlo y modificar algunas cosas. Como mínimo, hay que cambiar los ficheros de información (ftype=i):

i pkginfo=pkg/package/pkginfo
Además de definir cada objeto, en el fichero prototype se pueden hacer otras cosas:

  • definir objetos adicionales que se crean en la instalación
  • crear links durante la instalación
  • distribuir packages en múltiples volúmenes
  • anidar ficheros prototype
  • poner un valor por defecto para mode, owner y group
  • dar un path de búsqueda para pkgmk (en la construcción del package)
  • poner variables de entorno
Para crear un directorio (que no va incluido en el package file):
d none /directory 0644 root other
Para crear un fichero vacío:
f none filename=/dev/null 0644 bin bin
Para crear un link:
s none etc/mount=../usr/etc/mount
Para dar valores por defecto:
!default 0644 root other