Autor Tema: [SIG] Instalación de PostgreSQL y Postgis desde las fuentes.  (Leído 4076 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado mxgxw

  • Global Moderator
  • Trade Count: (1)
  • The Communiter-
  • *
  • Thank You
  • -Given: 27
  • -Receive: 652
  • Mensajes: 5660
  • Starlet - 999cc
    • mxgxw
Introducción

En las distribuciones de Linux, muchas veces nos encontraremos con la limitante de que los paquetes precompilados no poseen cierta funcionalidad o en el peor de los casos, el comportamiento de las funciones no es el esperado.

Utilizando herramientas OpenSource tenemos la ventaja de poder modificar cada pieza de software según nuestras necesidades.

A continuación se explican los pasos necesarios para la instalación del Postgresql 8.2.4 y Postgis 1.2.1 ademas de las bibliotecas de soporte GEOS 2.2.3 y Proj 4.5.0 para el uso en SIG.

Preparando la compilacion

Antes de comenzar, es recomendable crear un directorio donde guardaremos todos los codigos fuentes y realizaremos el proceso de compilación. Es necesario asegurarnos que nuestra distribución cuente con todas las herramientas de compilación necesaria, como el compilador gcc, g++, make, autoconf, automake, etc.

Nota: Para saber que paquetes se incluyen en las herramientas de desarrollo consulte con la documentación correspondiente a la distribución que esta utilizando.

Una vez nos hemos asegurado de contar con todas las herramientas necesarias, creamos nuestro directorio de fuentes:

Código: [Seleccionar]
user@someplace:~$ mkdir sources
user@someplace:~$ cd sources
user@someplace:~/sources $

Instalando GEOS

GEOS es una biblioteca con funciones geometricas, que es utilizada por postgis para manipular y modificar las geometrias de un SIG. Es necesario compilar esta biblioteca si queremos que la base de datos pueda realizar operaciones de creacion/modificacion de los datos geometricos almacenados.

Lo primero que vamos a hacer es obtener el codigo fuente de la siguiente dirección:

http://geos.refractions.net/

Descargaremos la última versión estable. Para el momento de escribir este tutorial correspondía a la 2.2.3.

http://geos.refractions.net/geos-2.2.3.tar.bz2

En la consola de linux podemos descargar fácilmente los archivos haciendo uso del comando wget:

Código: [Seleccionar]
user@someplace:~/sources$ wget http://geos.refractions.net/geos-2.2.3.tar.bz2

Luego debemos de descomprimir el archivo dentro del directorio de fuentes. Por lo general podemos descomprimir y extraer los archivos con un solo comando:

Código: [Seleccionar]
user@someplace:~/sources$ tar -xjf geos-2.2.3.tar.bz2

La configuración de GEOS es bastante sencilla, únicamente debemos de cambiarnos al directorio de fuentes y con el comando configure especificarle el directorio de instalación.

Asumiremos que no hay versiones previas instaladas y que todo el software que compilemos se colocara en la carpeta /usr

Código: [Seleccionar]
user@someplace:~/sources$ cd geos-2.2.3
user@someplace:~/sources/geos-2.2.3$ ./configure --prefix=/usr
...

Al terminar de configurar, si no falla ninguna de las dependencias, podemos comenzar a compilar utilizando el comando make.

Código: [Seleccionar]
user@someplace:~/sources/geos-2.2.3$ make
...

Para instalar la biblioteca GEOS solo tenemos que ejecutar como root, el comando "make install".

Código: [Seleccionar]
user@someplace:~/sources/geos-2.2.3$ su
Password:
root@someplace:~/sources/geos-2.2.# make install

Tambien podemos ejecutar "make install" sin necesidad de entrar a la cuenta de root, utilizando siempre el comando su.

Código: [Seleccionar]
user@someplace:~/sources/geos-2.2.3$ su -c "make install"
password:
...

Si estamos en un sistema debian, posiblemente tengamos acceso al comando sudo, que nos permitira ejecutar comandos como root.

Código: [Seleccionar]
user@someplace:~/sources/geos-2.2.3$ sudo make install
password:
...

Con esto deberíamos de tener instalada y funcionando la biblioteca GEOS.

Regresamos al directorio de fuentes con el siguiente comando:

Código: [Seleccionar]
user@someplace:~/sources/geos-2.2.3$ cd ..
user@someplace:~/sources$

Instalando Proj4

Proj4 es un conjunto de bibliotecas y utilidades que permiten realizar proyecciones cartograficas, como tambien conversión entre sistemas de referencia.

Podemos obtener Proj4 de la siguiente dirección.

http://proj.maptools.com

La version disponible a la fecha de escritura de este tutorial era la 4.5.0. También necesitaremos los datum grids de EEUU, Canada y Nueva Zelanda para agregar soporte de conversion de datum NAD27/NAD86 y NZGD49. La dirección de los archivos mencionados es la siguiente:

ftp://ftp.remotesensing.org/proj/proj-4.5.0.tar.gz
ftp://ftp.remotesensing.org/proj/proj-datumgrid-1.3.zip

Abrimos nuestra consola y descargamos los archivos necesarios:

Código: [Seleccionar]
user@someplace:~/sources$ wget ftp://ftp.remotesensing.org/proj/proj-4.5.0.tar.gz
...
user@someplace:~/sources$ wget ftp://ftp.remotesensing.org/proj/proj-datumgrid-1.3.zip
...

Primero descomprimimos el codigo fuente de Proj4:

Código: [Seleccionar]
user@someplace:~/sources$ tar -xzf proj-4.5.0.tar.gz

Cambiamos al directorio nad del codigo fuente de Proj4 y descomprimimos los datum shift que descargamos.

Código: [Seleccionar]
user@someplace:~/sources$ cd proj-4.5.0
user@someplace:~/sources/proj-4.5.0$ cd nad
user@someplace:~/sources/proj-4.5.0/nad $ unzip ../../proj-datumgrid-1.3.zip

Regresamos al directorio principal de las fuentes y con el comando configure especificamos nuestro directorio de instalación /usr

Código: [Seleccionar]
user@someplace:~/sources/proj-4.5.0/nad$ cd ..
user@someplace:~/sources/proj-4.5.0$ ./configure --prefix=/usr
...

Con esto Proj4 estará listo para compilarse, lo unico que queda es ejecutar el comando make para compilar las fuentes:

Código: [Seleccionar]
user@someplace:~/sources/proj-4.5.0$ make
...

Lo último que queda es instalar las bibliotecas y utilizades de proj4 con make install.

Código: [Seleccionar]
user@someplace:~/sources/proj-4.5.0$ su -c "make install"
password:
...

Una vez instalado proj4, regresamos al directorio de fuentes.

Código: [Seleccionar]
user@someplace:~/sources/proj-4.5.0$ cd ..
user@someplace:~/sources$

Compilando Postgresql

Postgresql es un gestor de base de datos relacional, con soporte para tipos de datos personalizados, funciones, desencadenadores, vistas que posee integridad referencial. Tambien soporta extesiones para el trabajo de información geográfica con las extensiones de Postgis.

Podemos obtener Postgresql de la siguiente dirección:

http://www.postgresql.org/

La versión a utilizar será la 8.2.4, que es la última versión estable de PostgreSQL al momento de escribir este tutorial.

http://wwwmaster.postgresql.org/download/mirrors-ftp?file=%2Fsource%2Fv8.2.4%2Fpostgresql-8.2.4.tar.bz2

Para descargar este archivo es necesario elejir un mirror, así que asumiremos que lo tenemos descargado y procedemos a descomprimir.

Código: [Seleccionar]
user@someplace:~/sources$ tar -xjf postgresql-8.2.4.tar.bz2

Nos cambiamos al directorio de fuentes y configuramos postgresql con algunas opciones personalizadas:

Código: [Seleccionar]
user@someplace:~/sources$ cd postgresql-8.2.4
user@someplace:~/sources/postgresql-8.2.4$ ./configure --prefix=/usr/lib/postgresql8 --sysconfdir=/etc/postgresql --datadir=/usr/share/postgresql8 --mandir=/usr/share/man --includedir=/usr/include/postgresql --with-tcl --with-perl --with-python --with-krb5 --with-pam  --with-openssl
...

--prefix= Directorio base de instalación de postgresql
--sysconfig= Directorio de busqueda para los archivos de configuración
--datadir= Directorio de datos del programa
--mandir= Directorio de instalacion de las páginas del manual
--includedir= Directorio de instalación de los archivos de cabecera para desarrollo
--with-tcl Habilitar soporte para extensiones en TCL
--with-perl Habilitar soporte para extensiones en PERL
--with-python Habilitar soporte para extensiones en Python
--with-krb5 Habilitar soporte para autenticacion kerberos
--with-pam Habilitar soporte para autenticacion PAM
--with-openssl Habilitar soporte para conexiones seguras

Nota: Puede que algunas de estas opciones no esten disponibles para una distribución en especifico. Lo mejor es correr el script y deshabilitar aquellas opciones que lanzen un error.

Si el script de configuración funciona adecuadamente, debemos de poder compilar el postgresql con el comando make.

Código: [Seleccionar]
user@someplace:~/sources/postgresql-8.2.4$ make
...

Si la compilación termina con éxito, solo hay que ejecutar el comando "make install" para realizar la instalación de postgresql.

Código: [Seleccionar]
user@someplace:~/sources/postgresql-8.2.4$ su -c "make install"
...

Inicializando una base de datos en PostgreSQL

Antes de utilizar una base de datos en postgresql debemos de realizar algunas configuraciones en el sistema. La primera de estas tareas es agregar un usuario y un grupo que se encargara de correr el servidor postgresql.

En linux podemos crear un grupo con el comando addgroup

Código: [Seleccionar]
user@someplace:~$ su -c "addgroup postgresql"
Password:

Crearemos tambien un usuario de sistema que se llame postgresql.

Código: [Seleccionar]
user@someplace:~$ su -c "adduser --system --home=/usr/lib/postgresql postgresql"
Password:

Una vez añadido un usuario y un grupo podemos inicializar la base de datos con este usuario.
Estos comandos se pueden ejecutar desde cualquier cuenta de usuario, pero resulta menos complicado ejecutarlos desde un shell como root.

Primero debemos de crear un directorio donde guardaremos los datos. Usaremos /data/postgresql/data en esta ocasión.
Código: [Seleccionar]
root@someplace:/# mkdir -p /data/postgresql/data

Cambiamos el propietario del directorio a postgresql.

Código: [Seleccionar]
root@someplace:/# chown -R postgres:postgres /data/postgresql

Inicializamos el directorio de la base de datos con el usuario postgres

Código: [Seleccionar]
root@someplace:/# sudo postgres -c "/usr/lib/postgresql/bin/initdb -E UTF-8 -U postgres -W /data/postgresql/data"
...

Este comando inicializara el directorio de datos de postgresql y nos preguntara por un password para el superusuario que se creara. El nombe del super usuario esta definido por el parámetro -U. El parámetro -E es la codificacion por defecto que utilizará nuestra base de datos. La opción -W es para que se nos pregunte el password del superusuario al ejecutar el comando.

Por último debemos de crear un script de inicialización para nuestro servidor posgres. El siguiente script puede ser copiado en /etc/init.d o en /etc/rc.d dependiendo de la distribución que utilize.

postgresql.rc
Código: [Seleccionar]
#!/bin/bash
case "$1" in
    start)
        echo -n "Starting PostgreSQL database server:"
        su postgres -c "/usr/lib/postgresql/bin/pg_ctl -D /data/postgresql/data start"
        echo "."
        ;;
    stop)
        echo -n "Stopping PostgreSQL database server:"
        su postgres -c "/usr/lib/postgresql/bin/pg_ctl -D /data/postgresql/data stop"
        echo "."
        ;;
    restart)
        su postgres -c "/usr/lib/postgresql/bin/pg_ctl -D /data/postgresql/data stop"
        su postgres -c "/usr/lib/postgresql/bin/pg_ctl -D /data/postgresql/data start"
        ;;
esac

exit 0

Nota: Para que el servidor arranque al inicializar el sistema, deberá de realizar otros cambios al sistema que dependen de la distribución que este usando. Deberá de revisar la documentación correspondiente para realizar esa tarea.

Luego de esto podemos iniciar o terminar el servidor postgres con los siguientes comandos:

Iniciar:
Código: [Seleccionar]
root@someplace:/# /etc/init.d/postgresql start

Terminar:
Iniciar:
Código: [Seleccionar]
root@someplace:/# /etc/init.d/postgresql stop

Con esto deberiamos de tener nuestro servidor postgresql listo y funcionando!!

Nota importate: Al inicializar el directorio de datos con la herramienta initdb, la seguridad por defecto del postgresql es muy permisiva. Es altamente recomendable que revise las opciones de seguridad antes de utilizar el servidor en ambientes de producción.

Modificando Postgis

La razón principal por la cual modificamos postgis fué que el generador de KML, agregaba automáticamente una etiqueta <MultiGeometry> a la salida del comando. Esto es útil cuando tu salida se convierte directamente en un KML, sin embargo, necesitabamos elejir por medio de nuestra aplicación que objetos iban a estar agrupados por <MultiGeometry>.

Para solventar este problema teníamos dos opciones, la primera era eliminar la etiqueta <MultiGeometry> de la cadena generada por la funcion AsKML.

La segunda, para reducir el costo de memoria y procesamiento fue modificar la función en postgis encargada de generar la salida y evitar que agregara la etiqueta.

Primero necesitamos obtener postgis de la siguiente dirección:

http://postgis.refractions.net/

La versión disponible a la hora de escribir este tutorial era la 1.2.1.

http://postgis.refractions.net/download/postgis-1.2.1.tar.gz

Descargamos el codigo fuente de postgis:

Código: [Seleccionar]
user@someplace:~/sources$ wget http://postgis.refractions.net/download/postgis-1.2.1.tar.gz
...

Descomprimimos el codigo fuente:

Código: [Seleccionar]
user@someplace:~/sources$ tar -xzf postgis-1.2.1.tar.gz
...

Entramos al directorio de fuentes de postgis:

Código: [Seleccionar]
user@someplace:~/sources$ cd postgis-1.2.1
user@someplace:~/sources/postgis-1.2.1$

Antes de compilar realizamos una pequeña modificación al archivo lwgeom/lwgeom_kml.c . Para eliminar la etiqueta de MultiGeometry solo es necesario comentar las siguientes líneas:

Linea 332 Columna 9:
Código: [Seleccionar]
kmltype = "MultiGeometry";
por:
Linea 332 Columna 9:
Código: [Seleccionar]
//kmltype = "MultiGeometry";

Linea 334 Columna 9:
Código: [Seleccionar]
ptr += sprintf(ptr, "<%s>", kmltype);
por:
Linea 334 Columna 9:
Código: [Seleccionar]
//ptr += sprintf(ptr, "<%s>", kmltype);

Linea 369 Columna 9:
Código: [Seleccionar]
ptr += sprintf(ptr, "</%s>", kmltype);
por:
Linea 369 Columna 9:
Código: [Seleccionar]
//ptr += sprintf(ptr, "</%s>", kmltype);

Una vez hemos realizado las modificaciones procedemos a configurar el postgis de manera similar a ocmo lo hemos hecho con las demas fuentes.

Postgis por defecto no incluye el soporte para funciones geometricas ni proj4. Por eso es necesario compilar las bibliotecas de GEOS y Proj4 antes de compilar Postgis.

Ejecutamos el script de configuración:
Código: [Seleccionar]
user@someplace:~/sources/postgis-1.2.1$ ./configure --prefix=/usr --with-pgsql=/usr/lib/postgresql/bin/pg_config --with-geos=/usr/bin/geos-config --with-proj=/usr

--with-pgsql= Ubicacion del archivo pg_config de postgresql
--with-geos= Ubicacion del archivo geos-config para soportar las funciones de GEOS
--with-proj= Directorio base de instalación de Proj4 para el soporte de retroproyecciones

Si todo el software quedo instalado de manera adecuada, el script configure terminara con exito y podremos ejecutar el comando make para compilar las fuentes.

Código: [Seleccionar]
user@someplace:~/sources/postgis-1.2.1$ make

Por último solo queda instalar el postgis con el comando "make install"

Código: [Seleccionar]
user@someplace:~/sources/postgis-1.2.1$ su -c "make install"
Password:
...

Con este último paso deberíamos de tener instalado postgis y podremos configurar una base de datos para soportar datos geográficos.

Inicialización de una base de datos geográfica

Primero es necesario crear una base de datos. Nos conectaremos utilizando./psq como base de datos uno de las bases de datos template1 y el usuario postgres que utilizamos  que se genera por defecto.

Nota: Debes asegurarte que la base de datos este corriendo. Puedes ejecutar como root "/etc/init.d/postgresql start" para iniciarla.

Nos conectamos a postgres y creamos la nueva base de datos con el comando create database. La base de datos que crearemos se llamará sig.
Código: [Seleccionar]
user@someplace:$ /usr/lib/postgresql/bin/psql -U postgres template1
Password for user postgres:

template1=# create database sig;
...

Un mensaje de confirmación nos indicará que la base de datos ha sido creada. Una vez hecho esto debemos de cargar las funciones y operadores de postgis. Pero antes de ello debemos de habilitar el lenguaje plpgsql para la base de datos que creamos. Eso lo haremos con el comando createlang.

Código: [Seleccionar]
user@someplace:$ /usr/lib/postgresql/bin/createlang -U postgres sig
Password for user postgres:
...

Un mensaje de confirmación nos indicara que el lenguaje plpgsql se ha creado para la base de datos "gis". Ahora solo debemos de importar las funciones y tipos para postgis. Esto lo hacemos con el siguiente comando:

Código: [Seleccionar]
user@someplace:$ /usr/lib/postgresql/bin/psql -U postgres template1 < /usr/share/lwpostgis.sql

Por último debemos insertar el set de sistemas de referencia que se incluye con postgis, esto se hace para facilitar las operaciones en que debamos trabajar con geometrias en diferentes sistemas de referencia.

Código: [Seleccionar]
user@someplace:$ /usr/lib/postgresql/bin/psql -U postgres template1 < /usr/share/spatial_ref_sys.sql

Con esto deberíamos de tener lista nuestra base de datos geográfica correctamente inicializada y con todos los datos básicos necesarios.

Conclusión

El Configurar e instalar las bibliotecas para geometrias y projecciones desde las fuentes nos garantiza tener toda la funcionalidad que requiramos en nuestra instalación de postgis. Además nos facilita el trabajo de actualización ya que utilizamos las rutas por defecto del sistema. También nos da la ventaja de poder modificar cada una de las aplicaciones segun necesidades especificas, o expandir la funcionalidad según sea necesario.
« Última Modificación: junio 20, 2007, 10:15:29 pm por mxgxw »