CKAN es un poderoso sistema de gestión de datos que permite hacer la información accesible, agilizando la publicación, y proveyendo herramientas para compartir, encontrar y utilizar datos. CKAN apunta a entidades (gobiernos, compañías y organizaciones) que desean hacer sus datos abiertos y públicos.

Este artículo explica la instalación completa de CKAN desde sus fuentes en un sistema Debian 7, incluyendo la configuración del DataStore, FileStore, DataPusher, y el plugin "ckanext-basiccharts" (para gráficos de torta, barra y otros).

CKAN es una herramienta para crear sitios web open data (sitios web donde hacer pública información perteneciente a entidades u organizaciones ). Puede ser visto como una especie de sitio Wordpress, aunque orientado a datos en vez de artículos y/o publicaciones. Esta herramienta permite gestionar y publicar colecciones de datos. Es utilizada generalmente por entidades gubernamentales, ONGs, instituciones de investigación, y otras organizaciones que colectan datos de dominio público.

Una vez que los datos se hacen públicos, los usuarios del sitio pueden usar las características de búsqueda para navegar y encontrar datos, y previsualizarlos utilizando mapas, gráficos y tablas (así sean desarrolladores, periodistas, investigadores, ONGs, ciudadanos, etc.)

Los datos son publicados en lo que CKAN llama "datasets". Un dataset es una porción de datos (por ejemplo, pueden datos estadísticos sobre una región, balances financieros para un departamento de estado, o lecturas de temperatura para una estación meteorológica. Cuando los usuarios buscan información, los resultados de estas búsquedas serán a su vez datasets individuales.

Para más información acceder a: CKAN documentation - User guide.

Desde el punto de vista tecnológico, CKAN es un "frankestein" implementado en Python y PostgreSQL (utiliza libpq como interfaz a Postgres). Pero además utiliza pip como gestor de paquetes (módulos) Python, virtualenv para correr la aplicación en un entorno virtual Python aislado, Apache Solr como plataforma de búsqueda, OpenJDK (pues Solr está implementado en Java), y Jetty como front-end para Solr. Como si esto fuera poco, utiliza Apache con mod_wsgi como interfaz (front-end) a la aplicación Python, y a su vez Nginx como proxy reverso a modo de cache. Esto significa que se requiere de una importante infraestructura donde desplegar todos estos servicios, sólo a un lunático se le ocurriría correr una aplicación Python con Postgres, Solr (Java), Jetty, Apache y Nginx en un mismo servidor. Salvo que se trate de un sistema en desarrollo o prueba, claro está. Este artículo explica detalladamente toda la instalación sobre un mismo servidor (a modo de demo o prueba), luego cada uno debe decidir cómo y en cuantos sistemas operativos diferentes dividir todos estos roles.

Más allá de las cuestiones técnicas de bajo nivel e implementación, CKAN parece una herramienta bien lograda, que ofrece funcionalidades muy interesantes para implementar un sitio open data, con interfaces (a mi gusto) muy limpias y amigables, bien diseñadas.

Habiendo presentado brevemente a CKAN, queda claro que la instalación desde sus fuentes es larga y tortuosa, y presenta un gran desafío para lograr que todas estas piezas interactuen correctamente. Dicho ésto, este artículo presenta todos los pasos de su instalación y puesta en funcionamiento a partir de los fuentes sobre un servidor Debian 7 "wheezy".

¿Por qué instalar desde los fuentes cuando es posible hacerlo automáticamente desde paquetes? Por dos razones, primero y principal, para comprender la mayor cantidad de detalles posibles acerca de su implementación, funcionamiento y componentes. Segundo, para saber con exactitud cuáles son sus requisitos mínimos y limitaciones, una cuestión de vital importancia a la hora de analizar si es viable su implementación en nuestra institución, de acuerdo a nuestros propios requisitos y limitaciones.

¿Por qué sobre Debian 7? Porque es la última versión estable de Debian en la que confío y tiene soporte hasta fines de mayo de 2018.

Manos a la obra

Antes de comenzar es recomendable actualizar el sistema:

# apt-get update && apt-get upgrade

Instalación de PostgreSQL

La versión de paquete de Debian 7 es algo anticuada (9.1), por lo que es preferible compilar e instalar la última versión estable (9.5) desde postgresql.org/ftp/source/:

# cd /usr/local/src
# wget https://ftp.postgresql.org/pub/source/v9.5.3/postgresql-9.5.3.tar.gz

Extraer y setear permisos:

# tar xzf postgresql*.tar.gz
# cd postgres*
# chown -R root:root .

A continuación, configurar el paquete para que se instale en el directorio /usr/local/pgsql:

# ./configure --prefix=/usr/local/pgsql --with-openssl

Compilar e instalar Postgres:

# make -j4 && make install && make clean

Si se requieren plugins de Postgres adicionales (por ejemplo pgcrypto), compilarlos e instalarlos desde el subdirectorio contrib/:

# cd contrib/pgcrypto/
# make
# cp pgcrypto.so /usr/local/pgsql/lib
# cp pgcrypto--*.sql pgcrypto.control /usr/local/pgsql/share/extension
# cd ../..

Una vez instalado, es necesario crear el usuario de PostgreSQL:

# useradd -s /bin/bash postgres
# mkdir /home/postgres

Luego es necesario crear e inicializar una instancia de Postgres, llamada "pg_ckan":

# mkdir /var/pgsql
# cd /var/pgsql
# chown postgres:postgres .
# su - postgres
$ cd /var/pgsql
$ initdb ./pg_ckan
$ mkdir pg_ckan/pg_log

Finalmente, crear script de inicio de servicio:

$ nano pg_ckan/postgres-pg_ckan

El script debe tener el siguiente contenido:

#!/bin/bash
### BEGIN INIT INFO
# Provides:          postgresql-pg_ckan
# Required-Start:    $local_fs $network $syslog $named
# Required-Stop:     $local_fs $network $syslog $named
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: PostgreSQL CKAN
# Description:       PostgreSQL CKAN
### END INIT INFO

. /etc/profile

if [ $# -eq 0 ] ; then
   echo "Available commands: start|stop|stopnow|restart|reload|status"
   exit 1
fi

PGDATA=/var/pgsql/pg_ckan
LOG="${PGDATA}/pg_log/$(date +%Y%m%d%H%M%S).log"

CMD=$1
if [ "${CMD}" == "stopnow" ] ; then
   PARAMS="--mode=fast"
   CMD="stop"
else
   PARAMS=""
fi

su - postgres -c "/usr/local/pgsql/bin/pg_ctl ${CMD} ${PARAMS} -D ${PGDATA} -l ${LOG}"

Cerrar la sesión del usuario "postgres" e instalar el servicio:

$ exit
# ln -s /var/pgsql/pg_ckan/postgresql-pg_ckan /etc/init.d/
# chmod +x /var/pgsql/pg_ckan/postgresql-pg_ckan

Iniciar el servidor Postgres:

# /etc/init.d/postgresql-pg_ckan start

Instalación de requerimientos de CKAN

La instalación procede de acuerdo al manual de instalación de CKAN desde los fuentes. Instalar las dependencias necesarias:

# apt-get install python-dev libpq-dev python-pip python-virtualenv git-core solr-jetty openjdk-6-jdk

Instalación de CKAN en un entorno virtual Python

CKAN corre en un entorno Python virtual aislado implementado con virtualenv. Esta herramienta permite crear entornos de ejecución de aplicaciones Python que tienen sus propios directorios de instalación, y no comparten librerías con otros entornos virtuales. Gracias a esto es posible lograr que convivan aplicaciones que tienen dependencias con diferentes versiones de una misma librería. También permite "freezar" una instalación para que no sea afectada por las actualizaciones de versiones de librerías y módulos que se lleven a cabo en el directorio site-packages global de Python.

Ejecutar los siguientes pasos a fin de crear y activar el entorno virtual:

# mkdir -p /usr/local/lib/ckan/default
# virtualenv --no-site-packages /usr/local/lib/ckan/default
# . /usr/local/lib/ckan/default/bin/activate

El entorno virtual queda activo, y es importante que permanezca activo durante toda la instalación (notar la identificación del entorno en el prompt):

(default)root@ckan-demo:/usr/local/lib#

Si en algún momento se cierra sesión, es posible reactivar el entorno virtual ejecutando: . /usr/local/lib/ckan/default/bin/activate.

A continuación, descargar el código fuente de CKAN:

(default)root@ckan-demo:/usr/local/lib# pip install -e 'git+https://github.com/ckan/ckan.git@ckan-2.5.2#egg=ckan'

E instalar los módulos de Python necesarios:

(default)root@ckan-demo:/usr/local/lib# pip install six
(default)root@ckan-demo:/usr/local/lib# pip install -r /usr/local/lib/ckan/default/src/ckan/requirements.txt

Este proceso debe finalizar con éxito:

Successfully installed argparse pytz pyutilib.component.core repoze.lru repoze.who-friendlyform repoze.who requests routes simplejson solrpy sqlalchemy-migrate sqlalchemy sqlparse tempita tzlocal unicodecsv vdm weberror webhelpers webob webtest zope.interface html5lib
Cleaning up...

Instalación de la base de datos PostgreSQL

Cambiar al usuario "postgres":

# su - postgres

Crear el usuario "usr_ckan" (se debe especificar una contraseña de manera interactiva, la cual deberá ser recordada para utilizar más adelante):

$ createuser -S -D -R -P usr_ckan

Y la base de datos "ckan", propiedad del usuario "usr_ckan":

$ createdb -O usr_ckan ckan -E utf-8

Luego crear la configuración de CKAN (con el entorno virtual activo):

(default)root@ckan-demo:~# mkdir -p /etc/ckan/default
(default)root@ckan-demo:~# paster make-config ckan /etc/ckan/default/development.ini

Editar la configuración para apuntar a la base de datos recién creada:

(default)root@ckan-demo:~# nano /etc/ckan/default/development.ini

Editar el string de conexión a la base Postgres (reemplazar los asteriscos por la contraseña), el string de conexión a la base Solr, y la URL del sitio:


sqlalchemy.url = postgresql://usr_ckan:****@localhost/ckan

ckan.site_url = http://ckan-demo.linuxito.com

solr_url = http://localhost:8983/solr      # con 127.0.0.1 no funciona

Finalmente, crear el link al archivo who.ini:

(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# ln -s /usr/local/lib/ckan/default/src/ckan/who.ini /etc/ckan/default/

Configuración de Apache Solr

CKAN utiliza Apache Solr como plataforma de búsqueda, el cual a su vez requiere un servidor Web Java, que puede ser Jetty, Tomcat u otro. Esta guía utiliza Jetty, el cual fue instalado desde los paquetes oficiales de Debian durante la instalación de requisitos.

Configurar Jetty editando el archivo /etc/default/jetty:

(default)root@ckan-demo:~# nano /etc/default/jetty

Editar las siguientes variables:

NO_START=0
JETTY_HOST=0.0.0.0 # CAMBIAR A 127.0.0.1
JETTY_PORT=8983

Iniciar Jetty ejecutando:

(default)root@ckan-demo:~# service jetty start

Si se abre el puerto 8983 en el firewall del servidor, es posible verificar el funcionamiento de Jetty accediendo a http://ckan-demo.linuxito.com:8983.

A continuación, hacer un backup del schema de Solr:

(default)root@ckan-demo:~# mv /etc/solr/conf/schema.xml /etc/solr/conf/schema.xml.bak

Y crear un link simbólico al schema de CKAN:

(default)root@ckan-demo:~# ln -s /usr/local/lib/ckan/default/src/ckan/ckan/config/solr/schema.xml /etc/solr/conf/schema.xml

Reiniciar Jetty y verificar accediendo a la URK http://ckan-demo.linuxito.com:8983/solr.

(default)root@ckan-demo:~# service jetty restart

Al intentar acceder al recurso "/solr", el servidor Jetty responde con error HTTP 404 "Not Found". Esto se debe a un error en el paquete solr-jetty en Debian 7, pues el link simbólico a la configuración de la applicación de Solr está roto (/var/lib/jetty/webapps/solr).

Arreglar el link simbólico de la siguiente forma:

(default)root@ckan-demo:~# rm /var/lib/jetty/webapps/solr
(default)root@ckan-demo:~# ln -s /usr/share/solr/web/ /var/lib/jetty/webapps/solr

Luego es necesario modificar la configuración de Jetty (otro bug de Debian 7 #740596) para incluir el archivo tomcat-coyote.jar:

(default)root@ckan-demo:~# echo /usr/share/java/tomcat-coyote.jar >> /etc/jetty/start.config

Reiniciar Jetty:

(default)root@ckan-demo:~# service jetty restart

De esta forma, funciona correctamente:

Por último es necesario cerrar el puerto 8983 en firewall (si es que había sido previamente abierto) para evitar que cualquiera pueda acceder a Solr.

Creación de las tablas de la base de datos de CKAN

Crear el archivo de configuración de desarrollo (debe estar activo el entorno virtual y se debe cambiar al directorio /usr/local/lib/ckan/default/src/ckan/):

(default)root@ckan-demo:~# cd /usr/local/lib/ckan/default/src/ckan/
(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# paster db init -c /etc/ckan/default/development.ini 

La salida de este comando debe ser Initialising DB: SUCCESS.

Configuración del DataStore

El DataStore es una extensión de CKAN que provee una base de datos ad hoc para almacenamiento de datos estructurados a partir de recursos de CKAN. Los datos pueden ser obtenidos desde archivos y almacenados en el DataStore. Cuando se agrega un recurso al DataStore se obtienen pre-visualizaciones automáticas en la página de recursos utilizando la extensión "Data Explorer". Además es posible buscar, filtrar y actualizar datos sin necesidad de descargarlos y volverlos a subir gracias a la API que provee.

El DataStore está integrado a la API y al sistema de autorización de CKAN.

Generalmente es usado junto con el DataPusher, el cual es capaz de agregar datos al DataStore de forma automática para los formatos de archivo soportados, ya sean subidos al FileStore o enlazados desde sitios externos.

El primer paso para poner en funcionamiento al DataStore consiste en habilitar el plugin en la configuración de CKAN:

(default)root@ckan-demo:~# /etc/ckan/default/nano development.ini

Agregar datastore en la variable ckan.plugins:

ckan.plugins = stats text_view image_view recline_view datastore

Crear el usuario PostgreSQL "usr_ckandatastore", necesario para que el DataStore tenga acceso a las bases de datos Postgres (guardar la contraseña):

(default)root@ckan-demo:/etc/ckan/default# su - postgres
postgres@ckan-demo:~$ createuser -S -D -R -P -l usr_ckandatastore

Crear la base de datos para el DataStore, propiedad de "usr_ckan" (el usuario con el que se conecta CKAN):

postgres@ckan-demo:~$ createdb -O usr_ckan ckan_datastore -E utf-8
postgres@ckan-demo:~$ exit

Configurar el acceso a la base de datos del DataStore:

(default)root@ckan-demo:~# nano /etc/ckan/default/development.ini

Reemplazar los asteriscos por las contraseñas correspondientes:

ckan.datastore.write_url = postgresql://usr_ckan:****@localhost/ckan_datastore
ckan.datastore.read_url = postgresql://usr_ckandatastore:****@localhost/ckan_datastore

El usuario "usr_ckan" tiene acceso de escritura a la base de datos del DataStore, mientras que el usuario "usr_ckandatastore" tiene acceso de sólo lectura.

A continuación, generar la configuración de permisos para las bases de datos (con el entorno de CKAN activo):

(default)root@ckan-demo:~# cd /usr/local/src/ckan/
(default)root@ckan-demo:/usr/local/src/ckan# paster --plugin=ckan datastore set-permissions -c /etc/ckan/default/development.ini > datastore-permissions.sql

Luego aplicar los permisos de acceso a la bases de datos con el usuario "postgres":

(default)root@ckan-demo:/usr/local/src/ckan# cp datastore-permissions.sql /home/postgres/
(default)root@ckan-demo:/usr/local/src/ckan# su - postgres
postgres@ckan-demo:~$ cat datastore-permissions.sql | psql --set ON_ERROR_STOP=1

Verificación del funcionamiento de CKAN

Primero es necesario abrir el puerto 5000 en el firewall del servidor.

Cambiar al directorio base:

# cd /usr/local/lib/ckan/default/src/ckan/

Activar el entorno (si no se encuentra activo):

# . /usr/local/lib/ckan/default/bin/activate)

Iniciar el servidor ejecutando:

paster serve /etc/ckan/default/development.ini
(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# paster serve /etc/ckan/default/development.ini 
2016-05-16 08:42:52,457 CRITI [ckan.lib.uploader] Please specify a ckan.storage_path in your config
                         for your uploads
Starting server in PID 20035.
serving on 0.0.0.0:5000 view at http://127.0.0.1:5000

Desde un navegador, acceder a la URL http://ckan-demo.linuxito.com:5000:

Además, verificar el funcionamiento del DataStore accediendo al recurso /api/3/action/datastore_search?resource_id=_table_metadata:

La salida es una respuesta en formato JSON que contiene información acerca del DataStore.

Deploy de CKAN a producción

Crear el archivo production.ini copiando el de desarrollo:

(default)root@ckan-demo:/tmp# cp /etc/ckan/default/development.ini /etc/ckan/default/production.ini

Instalar Apache, el cual funciona como front-end a la aplicación Python:

# apt-get install apache2 libapache2-mod-wsgi libapache2-mod-rpaf

De esta forma se relega todo lo relacionado al protocolo HTTP al servidor Apache (principalmente todo aquello relacionado a la seguridad, como por ejemplo el soporte para SSL).

CKAN utiliza WSGI como interfaz entre el servidor Web (front-end) y la aplicación Python. Esto permite que se pueda utilizar cualquier servidor Web, no necesariamente Apache, con cualquier tipo de configuraciones, por ejemplo: Apache con mod_wsgi (tal como está implementado en esta guía); Apache o Nginx como proxy reverso a paster; Nginx con uWSGI.

La guía de deploy de CKAN sugiere instalar, además de Apache, Nginx como proxy reverso a Apache para implementar un mecanismo de caching. Esto no es necesario para sitios pequeños (o de prueba), por lo que esta guía omite la instalación de Nginx

Una vez instalado Apache, crear el archivo apache.wsgi:

(default)root@ckan-demo:/tmp# cd /etc/ckan/default/
(default)root@ckan-demo:/etc/ckan/default# nano apache.wsgi

Debe tener el siguiente contenido:

import os
activate_this = os.path.join('/usr/local/lib/ckan/default/bin/activate_this.py')
execfile(activate_this, dict(__file__=activate_this))

from paste.deploy import loadapp
config_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'production.ini')
from paste.script.util.logging_config import fileConfig
fileConfig(config_filepath)
application = loadapp('config:%s' % config_filepath)

Luego crear y configurar el VirtualHost "ckan":

(default)root@ckan-demo:/etc/ckan/default# cd /etc/apache2/sites-available/
(default)root@ckan-demo:/etc/ckan/default# nano ckan
<VirtualHost *:80>
    ServerName ckan-demo.linuxito.com

    WSGIScriptAlias / /etc/ckan/default/apache.wsgi

    # Pass authorization info on (needed for rest api).
    WSGIPassAuthorization On

    # Deploy as a daemon (avoids conflicts between CKAN instances).
    WSGIDaemonProcess ckan_default display-name=ckan_default processes=2 threads=15

    WSGIProcessGroup ckan_default

    ErrorLog /var/log/apache2/ckan.error.log
    CustomLog /var/log/apache2/ckan.custom.log combined

</VirtualHost>

Para sitios en producción se debe reemplazar esta configuración por el VirtualHost "ckan-ssl", que incluya la configuración de SSL, e idealmente se fuerce el uso de HTTPS

Habilitar el sitio "ckan" y deshabilitar el sitio por defecto:

(default)root@ckan-demo:/etc/apache2/sites-available# a2ensite ckan
(default)root@ckan-demo:/etc/apache2/sites-available# a2dissite default
(default)root@ckan-demo:/etc/apache2/sites-available# a2dissite default-ssl 
(default)root@ckan-demo:/etc/apache2/sites-available# service apache2 reload

Instalación del DataPusher

Antes de instalar el Web service "DataPusher", instalar las dependencias necesarias:

# apt-get install libxslt1-dev libxml2-dev

Luego crear un nuevo entorno virtual Python para el DataPusher (antes cerrar el entorno virtual de CKAN ejecutando deactivate):

(default)root@ckan-demo:/etc/apache2/sites-available# deactivate
root@ckan-demo:/etc/apache2/sites-available# cd /usr/local/lib/ckan/
root@ckan-demo:/usr/local/lib/ckan# virtualenv /usr/local/lib/ckan/datapusher

Crear el directorio para los fuentes del DataPusher:

root@ckan-demo:/usr/local/lib/ckan# mkdir datapusher/src
root@ckan-demo:/usr/local/lib/ckan# cd datapusher/src/

Descargar la última versión estable:

root@ckan-demo:/usr/local/lib/ckan/datapusher/src# git clone -b stable https://github.com/ckan/datapusher.git

Instalar el DataPusher:

root@ckan-demo:/usr/local/lib/ckan/datapusher/src# cd datapusher/

Activar el entorno virtual Python del DataPusher:

root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# . /usr/local/lib/ckan/datapusher/bin/activate

A continuación, instalar los requerimientos de Python necesarios:

(default)root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# /usr/local/lib/ckan/datapusher/bin/pip install -r requirements.txt
(default)root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# /usr/local/lib/ckan/datapusher/bin/python setup.py develop

Copiar la configuración de Apache para el DataPusher:

root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# cp deployment/datapusher.conf /etc/apache2/sites-available/datapusher

Copiar el script WSGI del DataPusher:

root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# cp deployment/datapusher.wsgi /etc/ckan/

Editar el script y corregir la ruta donde se activa el entorno virtual (en caso de haber elegido una ruta de instalación de CKAN distinta a la que se utiliza por defecto):

root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# nano /etc/ckan/datapusher.wsgi

Editar la ruta en la función os.path.join:

activate_this = os.path.join('/usr/local/lib/ckan/datapusher/bin/activate_this.py')

Copiar el script de configuración del DataPusher:

root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# cp deployment/datapusher_settings.py /etc/ckan/

Configurar Apache para que acepte peticiones en el puerto 8800 (puerto por defecto del DataPusher):

root@ckan-demo:/usr/local/lib/ckan/datapusher/src/datapusher# cd /etc/apache2/
root@ckan-demo:/etc/apache2# nano ports.conf
NameVirtualHost *:80
NameVirtualHost *:8800

Listen 80
Listen 8800

Una vez modificada la configuración de puertos, habilitar el VirtualHost del DataPusher y reiniciar Apache:

root@ckan-demo:/etc/apache2# a2ensite datapusher
root@ckan-demo:/etc/apache2# service apache2 reload

Finalmente, habilitar el plugin del DataPusher en la configuración de CKAN:

(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# nano /etc/ckan/default/production.ini 

Agregar "datapusher" en la variable ckan.plugins:

ckan.plugins = stats text_view image_view recline_view datastore datapusher

Y configurar los formatos soportados y la URL del DataPusher:

ckan.datapusher.formats = csv xls xlsx tsv application/csv application/vnd.ms-excel application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
ckan.datapusher.url = http://localhost:8800/

Creación del usuario administrador de CKAN

El usuario "admin" es el que tiene acceso irrestricto a todas las funcionalidades y configuraciones del sitio. Es necesario para efectuar todas las tareas de administración, como por ejemplo la creación de usuarios, etc.

Activar el entorno virtual de CKAN (cerrar antes el entorno virtual del DataPusher):

(default)root@ckan-demo:/etc/apache2# deactivate
root@ckan-demo:/etc/apache2# . /usr/local/lib/ckan/default/bin/activate
(default)root@ckan-demo:/etc/apache2# cd /usr/local/lib/ckan/default/src/ckan/

Crear el usuario "admin":

(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# paster sysadmin add admin -c /etc/ckan/default/production.ini

Creación de datos de prueba

Esta configuración es opcional. Tiene el propósito de insertar algunos datos de ejemplo para probar la aplicación:

Con el entorno virtual de CKAN activo, ejecutar:

(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# paster create-test-data -c /etc/ckan/default/production.ini

Configuración del sitio

En el archivo production.ini es posible configurar algunas variables:

(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# nano /etc/ckan/default/production.ini 

Modificar el título del sitio:

## Front-End Settings
ckan.site_title = CKAN Linuxito

Cambiar el idioma del sitio a español:

## Internationalisation Settings
ckan.locale_default = es
ckan.locale_order = es en pt_BR ja it cs_CZ ca fr el sv sr sr@latin no sk fi ru de pl nl bg ko_KR hu sa sl lv

Configuración de correo:

## Email settings

email_to = ckan.admin@linuxito.com
error_email_from = paste@ckan
#smtp.server = localhost
#smtp.starttls = False
#smtp.user = your_username@gmail.com
#smtp.password = your_password
#smtp.mail_from = paste@ckan

Guardar los cambios y recargar la configuración de Apache:

(default)root@ckan-demo:/usr/local/lib/ckan/default/src/ckan# service apache2 reload

Configuración del FileStore (uploads)

El FileStore requiere un directorio donde guardar las subidas (uploads) con permiso de escritura para Apache:

(datapusher)root@ckan-demo:/backup# mkdir /usr/local/lib/ckan/default/uploads
(datapusher)root@ckan-demo:/backup# nano /etc/ckan/default/production.ini

En el archivo de configuración production.ini, configurar la variable ckan.storage_path:

# FileStore uploads
ckan.storage_path = /usr/local/lib/ckan/default/uploads

Otorgar permisos de escritura para Apache ("www-data" en Debian y derivados):

(datapusher)root@ckan-demo:/backup# chown www-data:www-data /usr/local/lib/ckan/default/uploads/

Recargar la configuración de Apache:

(datapusher)root@ckan-demo:/backup# service apache2 reload

Configuración de los plugins de visualización

Los plugins de visualización ofrecen diferentes tipos de vistas para los recursos subidos al sitio. Editar el archivo de configuración de CKAN:

(datapusher)root@ckan-demo:/backup# nano /etc/ckan/default/production.ini

Agregar los plugins "recline_grid_view recline_graph_view recline_map_view linechart barchart piechart basicgrid" en la variable ckan.plugins:

ckan.plugins = stats text_view image_view recline_view datastore datapusher recline_grid_view recline_graph_view recline_map_view linechart barchart piechart basicgrid

Instalación del plugin ckanext-basiccharts

El plugin ckanext-basiccharts provee los gráficos lineales, de barra y torta a CKAN. Se debe instalar luego del paso anterior, pues es el que provee los plugins linechart, barchart, piechart y basicgrid.

Crear un directorio donde guardar los fuentes de plugins y descargar la última versión:

(datapusher)root@ckan-demo:/backup# cd /usr/local/lib/ckan/
(datapusher)root@ckan-demo:/usr/local/lib/ckan# mkdir plugins
(datapusher)root@ckan-demo:/usr/local/lib/ckan# cd plugins/
(datapusher)root@ckan-demo:/usr/local/lib/ckan/plugins# git clone https://github.com/ckan/ckanext-basiccharts.git

Instalar el paquete y recargar Apache:

(datapusher)root@ckan-demo:/usr/local/lib/ckan/plugins# cd ckanext-basiccharts/
(datapusher)root@ckan-demo:/usr/local/lib/ckan/plugins/ckanext-basiccharts# python setup.py install
(datapusher)root@ckan-demo:/usr/local/lib/ckan/plugins/ckanext-basiccharts# service apache2 reload

Con esto finaliza la instalación completa de CKAN desde los fuentes, incluyendo la configuración del DataStore, DataPusher, FileStore, plugins de visualización y las bases de datos Postgres y Solr.

Referencias

CKAN documentation - User guide

PostgreSQL

PostgreSQL Documentation - libpq - C Library

virtualenv - Virtual Python Environment builder

Apache Solr

OpenJDK

Jetty - Servlet Engine and Http Server

mod_wsgi

CKAN Features

PostgreSQL Documentation - pgcrypto

CKAN documentation - Installing CKAN from source

SchemaXml - Solr Wiki

CKAN documentation - DataStore extension

CKAN documentation - Deploying a source install

DataPusher Documentation - Production installation and Setup

DataPusher Documentation - CKAN Configuration

DataPusher Documentation - Using the DataPusher

CKAN documentation - Getting started

CKAN documentation - FileStore and file uploads

CKAN documentation - Data preview and visualization

ckanext-basiccharts


Tal vez pueda interesarte


Compartí este artículo