Memoria pfc, Metaproxy documentation

Deusto
Facultad de Ingeniería
Universidad de Deusto
Ingeniaritza Fakultatea
Deustuko Unibertsitatea

Ingeniero en Informática
Informatikako Ingeniaria

Proyecto fin de carrera
Karrera amaierako proiektua

Resumen

Actualmente, existe una problemática (principalmente en los móviles de última
generación) en lo referente a los datos que contienen las páginas web: muchas
aplicaciones tanto móviles como de escritorio, e incluso otras páginas web (como por
ejemplo, buscadores) requieren unos datos “extra” de las páginas web, para la
realización de una serie de funcionalidades específicas. A estos datos “extra” se les
denomina metadatos y en la actualidad, muchas veces estos datos no son visibles a
simple vista o no son presentados visualmente a los humanos de manera adecuada.

El objetivo de este proyecto es el de crear un servidor proxy que permita que
los metadatos (datos extra) de las páginas web convencionales puedan ser
visualizados de manera adecuada para los seres humanos mediante el uso de una de
las tecnologías de moda en los últimos tiempos: la Web Semántica.

El servidor proxy hará de intermediario entre el cliente que desea la página web
y el servidor que le proporciona dicha página web al cliente. Gracias al servidor proxy,
el cliente obtendrá una versión ligeramente modificada de la página web solicitada. El
servidor, aparte de obtener una copia de la página solicitada, extraerá de ella los
metadatos y los transformará en un formato adecuado para su posterior visualización
en formatos entendibles como XML o grafos. Es más, el servidor, también tendrá la
capacidad de insertar metadatos en las propias páginas si así se desea.

El manejo del servido proxy se realizará a través de un portal web
implementado mediante el framework de desarrollo web de código abierto Django, por
lo que el usuario del proxy únicamente deberá de disponer de un navegador web para
acceder a éste.

Para la configuración del servidor proxy se dispondrá de un panel de control al
cual sólo podrán acceder los administradores a través del portal mencionado en el
anterior párrafo. Mediante él, se podrán insertar datos en la base de datos, añadir
nuevas páginas al servidor para ser tratadas y hacer consultas especiales (SPARQL)
sobre los metadatos almacenados previamente extraídos de las páginas solicitadas.
Asimismo, también se podrá cambiar el comportamiento del servidor proxy, es decir, a
pesar de que por defecto el proxy esté configurado para la extracción/manejo de
metadatos, los usuarios podrán subir al servidor scripts en Python personalizados que
hagan que el servidor realice otras actividades como puede ser la traducción o la
modificación del aspecto de una página web o como se ha mencionado anteriormente,
la propia inserción de metadatos en páginas web tradicionales.

iii

Descriptores

 Web semántica

 Proxy

 Páginas web

 Interpretación de datos.

iv

Índice

1. Introducción______________________________________________________ 1
1.1 Acerca del proyecto ___________________________________________________ 1
1.2 Acerca de la documentación ____________________________________________ 1
2. Definición del proyecto _____________________________________________ 3
2.1 Objetivos ___________________________________________________________ 3
2.2 Alcance _____________________________________________________________ 4
2.2.1 Alcance del proyecto _______________________________________________________ 4
2.2.2 Alcance de la investigación __________________________________________________ 4
2.2.3 Alcance de la documentación ________________________________________________ 4
2.2.4 Alcance de la herramienta ___________________________________________________ 5

2.3 Producto final ________________________________________________________ 5
2.4 Descripción de la realización ____________________________________________ 6
2.4.1 Método de desarrollo: ______________________________________________________ 6
2.4.2 Tareas principales: _________________________________________________________ 7

2.5 Organización y equipo ________________________________________________ 10
2.6 Presupuesto ________________________________________________________ 12
2.7 Condiciones de ejecución _____________________________________________ 12
3. Conceptos básicos ________________________________________________ 15
3.1 Proxy ______________________________________________________________ 15
3.1.1 Tipos ___________________________________________________________________ 15
3.1.2 Funcionamiento __________________________________________________________ 17

3.2 Web Semántica _____________________________________________________ 17
3.2.1 Definición _______________________________________________________________ 17
3.2.2 Utilidades _______________________________________________________________ 17
3.2.3 Funcionamiento __________________________________________________________ 18

3.3 Ontologías _________________________________________________________ 20
3.4 SPARQL ____________________________________________________________ 21
3.5 Linked Data ________________________________________________________ 21
3.6 Expresiones regulares ________________________________________________ 22
3.7 GRDDL_____________________________________________________________ 26
3.7.1 Ejemplo con XHTML _______________________________________________________ 27
3.7.2 Microformatos ___________________________________________________________ 27

v

4. Justificación_____________________________________________________ 29
4.1 Beneficios técnicos ___________________________________________________ 29
4.2 Beneficios económicos ________________________________________________ 29
5. Investigación en tecnologías _______________________________________ 31
5.1 Visión general _______________________________________________________ 31
5.2 Recursos principales __________________________________________________ 31
5.2.1 Python _________________________________________________________________ 31
5.2.2 Django _________________________________________________________________ 35
5.2.3 Django-Revproxy _________________________________________________________ 40
5.2.4 Redland ________________________________________________________________ 43
5.2.5 Git ____________________________________________________________________ 51

5.3 Recursos ___________________________________________________________ 57
5.3.1 Restkit _________________________________________________________________ 57
5.3.2 LXML __________________________________________________________________ 58
5.3.3 Pygments _______________________________________________________________ 59
5.3.4 Python Graph & Graphviz __________________________________________________ 59
5.3.5 Beautiful Soup ___________________________________________________________ 63

6. Desarrollo ______________________________________________________ 65
6.1 Estructura del proyecto _______________________________________________ 65
6.1.1 Portal Web (Django) ______________________________________________________ 65
6.1.2 Proxy __________________________________________________________________ 81
6.1.3 Scripts _________________________________________________________________ 84

6.2 API ________________________________________________________________ 98
6.2.1 ModifyBodyBase _________________________________________________________ 98
6.2.2 Utilidades ______________________________________________________________ 100

7. Usos alternativos _______________________________________________ 103
7.1 Traducción ________________________________________________________ 103
7.1.1 Google API _____________________________________________________________ 103

7.2 Discapacitados _____________________________________________________ 105
7.3 Analizador de código malicioso ________________________________________ 105
7.4 Guardar datos______________________________________________________ 105
7.5 Notificaciones ______________________________________________________ 106
7.5.1 Redes sociales __________________________________________________________ 106
7.5.2 E-mails ________________________________________________________________ 106
7.5.3 SMS __________________________________________________________________ 107

7.6 Testeo de páginas web_______________________________________________ 107
7.6.1 Diseño ________________________________________________________________ 107
7.6.2 Actualizaciones _________________________________________________________ 107

vi

8. Conclusiones ___________________________________________________ 109
8.1 Objetivos alcanzados ________________________________________________ 109
8.2 Consideraciones ____________________________________________________ 109
8.3 Posibles mejoras futuras _____________________________________________ 110
9. Agradecimientos ________________________________________________ 113
10. Licencias _______________________________________________________ 115
10.1 Imágenes________________________________________________________ 115
10.2 Documentación __________________________________________________ 115
10.3 Proyecto ________________________________________________________ 120
10.4 Revproxy ________________________________________________________ 132
11. Glosario _______________________________________________________ 133
12. Bibliografía ____________________________________________________ 145
12.1 Proxys (Ver 3.1) __________________________________________________ 145
12.2 Web Semántica (Ver 3.2) ___________________________________________ 145
12.3 Ontologías (Ver 3.3) _______________________________________________ 145
12.4 SPARQL (Ver 3.4) _________________________________________________ 145
12.5 Linked Data (Ver 3.5) ______________________________________________ 146
12.6 Expresiones regulares (Ver 3.6) ______________________________________ 146
12.7 GRDDL (Ver 3.7) __________________________________________________ 146
12.8 Python (Ver 5.2.1) ________________________________________________ 146
12.9 Django (Ver 5.2.2)_________________________________________________ 146
12.10 Django revproxy (Ver 5.2.3) _________________________________________ 147
12.11 Redland (Ver 5.2.4)________________________________________________ 147
12.12 Git (Ver 5.2.5) ____________________________________________________ 147
12.13 Restkit (Ver 5.3.1) _________________________________________________ 147
12.14 LXML (Ver 5.3.2) __________________________________________________ 147
12.15 Pygments (Ver 5.3.3) ______________________________________________ 147
12.16 Python graph (Ver 5.3.4) ___________________________________________ 147
12.17 Beautiful Soup (Ver 5.3.5) __________________________________________ 148
12.18 Desarrollo (Ver 6) _________________________________________________ 148
12.19 Usos alternativos (Ver 7) ___________________________________________ 148
12.20 Conclusiones (Ver 8) _______________________________________________ 148

vii

12.21 Licencias (Ver 10) _________________________________________________ 148
12.22 Manual de usuario (Ver 13) _________________________________________ 148
12.23 Glosario (Ver 11) __________________________________________________ 149
12.24 Otros ___________________________________________________________ 149
13. Manual de usuario ______________________________________________ 151
13.1 Instalación _______________________________________________________ 151
13.1.1 Requisitos primarios _____________________________________________________ 151
13.1.2 Requisitos _____________________________________________________________ 151

13.2 Entorno de producción _____________________________________________ 155
13.2.1 Requisitos _____________________________________________________________ 155
13.2.2 Se presupone ___________________________________________________________ 155
13.2.3 Configurar Nginx ________________________________________________________ 155
13.2.4 Añadir configuración de Django uWSGI ______________________________________ 156
13.2.5 Script para hacer deploy de aplicaciones Django_______________________________ 157
13.2.6 Script de ejecucucíon uWSGI ______________________________________________ 157
13.2.7 Configuración Django ____________________________________________________ 159
13.2.8 Crear base de datos para Django ___________________________________________ 159
13.2.9 Ejecución en modo producción ____________________________________________ 159

13.3 Uso ____________________________________________________________ 161
13.3.1 Página principal _________________________________________________________ 161
13.3.2 Sección administración de la página web ____________________________________ 162
13.3.3 Sección Administrador proxy ______________________________________________ 164
13.3.4 Ejemplos sobre el proyecto _______________________________________________ 176

Tabla de Ilustraciones

Ilustración 2-1: Tabla de tareas ------------------------------------------------------------------------------------------------- 8
Ilustración 2-2: Diagrama de Gantt -------------------------------------------------------------------------------------------- 9
Ilustración 2-3: Esquema organizativo -------------------------------------------------------------------------------------- 10
Ilustración 3-1: Ilustración de un forward proxy -------------------------------------------------------------------------- 15
Ilustración 3-2: Ilustración de un proxy abierto --------------------------------------------------------------------------- 16
Ilustración 3-3: Ilustración de un proxy inverso --------------------------------------------------------------------------- 16
Ilustración 3-4: Estructura de la web semántica-------------------------------------------------------------------------- 19
Ilustración 3-5: Ejemplo de ontología --------------------------------------------------------------------------------------- 20
Ilustración 3-6: Conjunto de datos interconectados entre sí que componen la "Nube de Linked Data" --- 22
Ilustración 5-1: Logo de Python ----------------------------------------------------------------------------------------------- 31
Ilustración 5-2: Logo Django --------------------------------------------------------------------------------------------------- 35
Ilustración 5-3: Flujo ------------------------------------------------------------------------------------------------------------- 37
Ilustración 5-4: Estructura de un proyecto en Django------------------------------------------------------------------- 38

viii

Ilustración 5-5: Flujo de Django-Revproxy ---------------------------------------------------------------------------------- 41
Ilustración 5-6: Carpetas y archivos de Revproxy ------------------------------------------------------------------------- 43
Ilustración 5-7: Logo Git --------------------------------------------------------------------------------------------------------- 51
Ilustración 5-8: Estados de trabajo con Git --------------------------------------------------------------------------------- 54
Ilustración 5-9: Commits y branchs del proyecto visualizados en gitk----------------------------------------------- 55
Ilustración 5-10: Logo Github -------------------------------------------------------------------------------------------------- 55
Ilustración 5-11: Proyecto hospedado en Github ------------------------------------------------------------------------- 56
Ilustración 5-12: Branchs del proyecto en Github ------------------------------------------------------------------------- 57
Ilustración 5-13: Grafo creado con Graphviz ------------------------------------------------------------------------------- 61
Ilustración 6-1: Estructura del proyecto ------------------------------------------------------------------------------------- 65
Ilustración 6-2: Estructura de un paquete HTTP --------------------------------------------------------------------------- 83
Ilustración 6-3: Algunos argumentos de la cabecera de un paquete HTTP ---------------------------------------- 83
Ilustración 7-1: Clave de la API de Google -------------------------------------------------------------------------------- 104
Ilustración 7-2: Panel de control de API de Google --------------------------------------------------------------------- 104
Ilustración 13-1: Página principal ------------------------------------------------------------------------------------------- 161
Ilustración 13-2: Menú de la página principal --------------------------------------------------------------------------- 161
Ilustración 13-3: Páginas registradas en el proxy ----------------------------------------------------------------------- 162
Ilustración 13-4: Acceso al repositorio online con el código fuente ------------------------------------------------ 162
Ilustración 13-5: Login de la administración de la web---------------------------------------------------------------- 162
Ilustración 13-6: Pantalla principal del panel de adminsitración de la web ------------------------------------- 163
Ilustración 13-7: Añadir nuevo usuarios ----------------------------------------------------------------------------------- 163
Ilustración 13-8: Lista de usuarios ------------------------------------------------------------------------------------------ 164
Ilustración 13-9: Zoom de la lista de usuarios --------------------------------------------------------------------------- 164
Ilustración 13-10: Menú de administración del proxy (Manager) -------------------------------------------------- 165
Ilustración 13-11: Login administrador proxy ---------------------------------------------------------------------------- 165
Ilustración 13-12: Iconos del menú del Manager ----------------------------------------------------------------------- 166
Ilustración 13-13: RDF Uploader -------------------------------------------------------------------------------------------- 166
Ilustración 13-14: Subir archivo RDF desde la máquina local -------------------------------------------------------- 167
Ilustración 13-15: Selección del archivo RDF local ---------------------------------------------------------------------- 167
Ilustración 13-16: Descargar archivo RDF--------------------------------------------------------------------------------- 167
Ilustración 13-17: Selección de la base de datos donde almacenar el archivo RDF ---------------------------- 168
Ilustración 13-18: Página de inserción en base de datos correcta ------------------------------------------------- 168
Ilustración 13-19: Página para la inserción de ontologías ------------------------------------------------------------ 169
Ilustración 13-20: Inserción del nombre de la ontología -------------------------------------------------------------- 169
Ilustración 13-21: Inserción del enlace a la ontología ----------------------------------------------------------------- 169
Ilustración 13-22: Listado de ontologías almacenadas ---------------------------------------------------------------- 170
Ilustración 13-23: Consultas SPARQL --------------------------------------------------------------------------------------- 170
Ilustración 13-24: Selección de la base de datos en la que realizar la consulta--------------------------------- 171
Ilustración 13-25: Selección del formato para los resultados -------------------------------------------------------- 171
Ilustración 13-26: Caja de texto para la query SPARQL --------------------------------------------------------------- 171
Ilustración 13-27: Resultado de la consulta (query) en la base de datos ----------------------------------------- 172
Ilustración 13-28: Administración de scripts ----------------------------------------------------------------------------- 172
Ilustración 13-29: Selección del archivo del script ---------------------------------------------------------------------- 173
Ilustración 13-30: Selección de la página a la que pertenecerá el script ----------------------------------------- 173

ix

Ilustración 13-31: Scripts de cada página del proxy -------------------------------------------------------------------- 173
Ilustración 13-32: Visualizador de scripts---------------------------------------------------------------------------------- 174
Ilustración 13-33: Administrador de páginas web del proxy --------------------------------------------------------- 174
Ilustración 13-34: Identificador de la página ----------------------------------------------------------------------------- 175
Ilustración 13-35: Enlace de la página web ------------------------------------------------------------------------------- 175
Ilustración 13-36: Listado de las páginas registradas en el proxy -------------------------------------------------- 175
Ilustración 13-37: Página con un visualizador de tweets -------------------------------------------------------------- 176
Ilustración 13-38: Página personal de David Buján --------------------------------------------------------------------- 177
Ilustración 13-39: Página dipina --------------------------------------------------------------------------------------------- 177
Ilustración 13-40: Vista de RDF en XML ------------------------------------------------------------------------------------ 178
Ilustración 13-41: Grafo a partir del RDF/XML --------------------------------------------------------------------------- 178
Ilustración 13-42: Demostración de GRDDL ------------------------------------------------------------------------------ 179
Ilustración 13-43: XML de RDF ----------------------------------------------------------------------------------------------- 180
Ilustración 13-44: Grafo de RDF ---------------------------------------------------------------------------------------------- 180
Ilustración 13-45: XML generado a partir de GRDDL ------------------------------------------------------------------- 181
Ilustración 13-46: Grafo a partir de RDF/XML del GRDDL ------------------------------------------------------------- 181

Tabla de bloques de código fuente
Código 3-1: Ejemplo de expresión regular en Python ------------------------------------------------------------------- 26
Código 3-2: Declaración de transformación GRDDL en XHTML------------------------------------------------------- 27
Código 3-3: Declaración de transformación GRDDL para hcard con Microformatos --------------------------- 27
Código 3-4: Profile de GRDDL dentro de hcard ---------------------------------------------------------------------------- 28
Código 3-5: Datos de hcard conteninedo el XSL para transformar microformatos hcard en GRDDL ------- 28
Código 5-1: Ejemplo de una función en Python --------------------------------------------------------------------------- 33
Código 5-2: Ejemplo de una clase en Python ------------------------------------------------------------------------------ 33
Código 5-3 Ejemplo de un script (programa) en Python ---------------------------------------------------------------- 34
Código 5-4 Resultado del ejemplo anterior -------------------------------------------------------------------------------- 34
Código 5-5: Ejemplo de fichero urls.py -------------------------------------------------------------------------------------- 39
Código 5-6: Ejemplo models.py ----------------------------------------------------------------------------------------------- 39
Código 5-7: Traducción SQL de models.py --------------------------------------------------------------------------------- 39
Código 5-8: Ejemplo de views.py---------------------------------------------------------------------------------------------- 40
Código 5-9: Asignación de direcciones proxy ------------------------------------------------------------------------------ 42
Código 5-10: Asignación de urls en Django -------------------------------------------------------------------------------- 42
Código 5-11: Ejemplo RDF/XML ----------------------------------------------------------------------------------------------- 45
Código 5-12: Ejemplo N-Quads ------------------------------------------------------------------------------------------------ 45
Código 5-13: Ejemplo N-Triples ----------------------------------------------------------------------------------------------- 45
Código 5-14: Ejemplo Turtle --------------------------------------------------------------------------------------------------- 46
Código 5-15: Ejemplo TRiG ----------------------------------------------------------------------------------------------------- 46
Código 5-16: Ejemplo RSS (con RDF) ----------------------------------------------------------------------------------------- 47
Código 5-17: Ejemplo GRDDL (Sobre HTML) ------------------------------------------------------------------------------- 47
Código 5-18: Ejemplo RDFa (Sobre HTML) --------------------------------------------------------------------------------- 48
Código 5-19: Ejemplo Atom 1.0 ----------------------------------------------------------------------------------------------- 49

x

Código 5-20: Ejemplo Json ------------------------------------------------------------------------------------------------------ 49
Código 5-21: Ejemplo DOT (Grafos) ------------------------------------------------------------------------------------------ 49
Código 5-22: Ejemplo 1º de uso básico con restkit ----------------------------------------------------------------------- 58
Código 5-23: Ejemplo 2º de uso básico con restkit ----------------------------------------------------------------------- 58
Código 5-24: Ejemplo de lenguaje DOT en Graphviz --------------------------------------------------------------------- 60
Código 5-25: Código de ejemplo de Python Graph ----------------------------------------------------------------------- 63
Código 6-1: urls.py ---------------------------------------------------------------------------------------------------------------- 67
Código 6-2: manager/urls.py --------------------------------------------------------------------------------------------------- 68
Código 6-3: settings.py ----------------------------------------------------------------------------------------------------------- 69
Código 6-4: Fragmento de código de urls.py ------------------------------------------------------------------------------- 69
Código 6-5: Fragmento de código de la función de manager/rdf ---------------------------------------------------- 70
Código 6-6: código del método de descarga dentro de utils ----------------------------------------------------------- 71
Código 6-7: Código del método para tratar las subidas locales de RDF -------------------------------------------- 72
Código 6-8: Código para el almacenaje de RDFs en la base de datos ----------------------------------------------- 72
Código 6-9: Modelo de base de datos para las ontologías en Django ---------------------------------------------- 73
Código 6-10: Método que interactúa con las ontologías de la BD --------------------------------------------------- 74
Código 6-11: Método encargado de la página de queries -------------------------------------------------------------- 75
Código 6-12: Método encargado de la ejecución de queries SPARQL ----------------------------------------------- 75
Código 6-13: Método para añadir una web proxy ------------------------------------------------------------------------ 76
Código 6-14: Método para la eliminación de páginas web proxy ---------------------------------------------------- 77
Código 6-15: Método para la subida de scripts al servidor ------------------------------------------------------------- 78
Código 6-16: Método para la visualización de los scripts --------------------------------------------------------------- 78
Código 6-17: Fragmento de código de urls.py ----------------------------------------------------------------------------- 79
Código 6-18: Fragmento de código de /manager/urls.py -------------------------------------------------------------- 79
Código 6-19: manager/views.py----------------------------------------------------------------------------------------------- 80
Código 6-20: templates/registration/login.html -------------------------------------------------------------------------- 81
Código 6-21: ModifyBody.py de la página dbujan ------------------------------------------------------------------------ 87
Código 6-22: ModifyBody.py de la página slok ---------------------------------------------------------------------------- 90
Código 6-23: Comienzo del fichero ModifyBody.py por defecto ------------------------------------------------------ 91
Código 6-24: Método de la lógica en ModifyBody.py por defecto --------------------------------------------------- 92
Código 6-25: Método para modificación de la cabecera del HTML que está en ModifyBody.py ------------- 93
Código 6-26: Método para creación de todas las pestañas en ModifyBody.py ----------------------------------- 95
Código 6-27: Creación de una única pestaña en ModifyBody.py ----------------------------------------------------- 96
Código 6-28: Métodos para parser GRDDL en ModifyBody.py -------------------------------------------------------- 97
Código 6-29: Método que modifica el cuerpo del HTML en ModifyBody.py --------------------------------------- 98
Código 6-30: ModifyBodyBase.py --------------------------------------------------------------------------------------------- 99
Código 6-31: Reimplementación simple para un script del proxy -------------------------------------------------- 100
Código 6-32: Importar métodos del módulo Db ------------------------------------------------------------------------- 101
Código 6-33: Importar métodos del módulo Rdf ------------------------------------------------------------------------ 101
Código 6-34: Importar métodos del módulo utils ----------------------------------------------------------------------- 102
Código 13-1: Instalación de setuptools y pip ----------------------------------------------------------------------------- 152
Código 13-2: Instalación Django -------------------------------------------------------------------------------------------- 152
Código 13-3: Instalación Restkit --------------------------------------------------------------------------------------------- 152
Código 13-4: Instalación Pygments ----------------------------------------------------------------------------------------- 152

xi

Código 13-5: Instalación Beautiful Soup ----------------------------------------------------------------------------------- 152
Código 13-6: Instalación Lxml ------------------------------------------------------------------------------------------------ 152
Código 13-7: Obtención del código fuente de Graphviz --------------------------------------------------------------- 153
Código 13-8: Instalación de Graphviz--------------------------------------------------------------------------------------- 153
Código 13-9: Instalación Python-graphviz--------------------------------------------------------------------------------- 153
Código 13-10: Instalación Raptor -------------------------------------------------------------------------------------------- 154
Código 13-11: Instalación Rasqal -------------------------------------------------------------------------------------------- 154
Código 13-12: Instalación LibRDF -------------------------------------------------------------------------------------------- 154
Código 13-13: Imstalación Python Redland bindings------------------------------------------------------------------- 154
Código 13-14: Archivo de configuración de Nginx ---------------------------------------------------------------------- 156
Código 13-15: Configuración de Django para uWSGI ------------------------------------------------------------------ 156
Código 13-16: Script para deploy de aplicaciones Django con uWSGI --------------------------------------------- 157
Código 13-17: Script de comando uWSGI --------------------------------------------------------------------------------- 159
Código 13-18: Usuario y clave de la BD en settings.py----------------------------------------------------------------- 159
Código 13-19: Usuarío y clave de la BD en manager/views.py ------------------------------------------------------ 159
Código 13-20: Comando para la creación de las tablas de Django en la BD ------------------------------------- 159
Código 13-21: Comando para arrancar demonio de Nginx ----------------------------------------------------------- 160
Código 13-22: Comando para arrancar script de deploy -------------------------------------------------------------- 160
Código 13-23: Ejemplo de query SPARQL ---------------------------------------------------------------------------------- 171

xii

PROYECTO FIN DE CARRERA

1. INTRODUCCIÓN

1.1 ACERCA DEL PROYECTO
En la actualidad, la Web está llena de páginas dispersas por todo el planeta, de
diferentes sitios y con contenido diverso y variado. Por ello, cada vez es más complejo
unificar, encontrar, organizar y obtener datos de ellas.

La Web Semántica intenta hacer todo esto más fácil proporcionándonos
nuevas tecnologías y herramientas como son los RDF, Ontologías, Endpoints
SPARQL, Linked Data, etc. Para ello, las páginas actuales deben actualizarse y ser
modificadas de forma que puedan utilizar toda la potencia de la Web Semántica, cuyo
objetivo no es más que el de crear una Web (en su totalidad) llena de metadatos.

Este proyecto está orientado hacia la Web Semántica. Es decir, trabaja con
páginas web que estén preparadas para trabajar con metadatos, les extrae esos
metadatos y los representa de forma visible al ojo humano.

Sin embargo, debido al diseño flexible del proyecto, éste puede usarse a su vez
para trabajar de otras formas que no tengan que ver con los metadatos. Una breve
explicación de esto último es que al tratarse el proyecto de un proxy que modifica el
comportamiento de la página que se solicita, por defecto crea una visualización
adecuada de los metadatos. Sin embargo, es posible modificar este último
comportamiento y hacer que en vez de visualizar metadatos realice otras utilidades,
como por ejemplo, cambiar el aspecto visual de una página web.

1.2 ACERCA DE LA DOCUMENTACIÓN
Esta documentación pretende ser un punto de referencia para interiorizar y
entender el proyecto, desde los pilares más básicos como es el diseño y la idea en sí
(incluyendo una explicación de ciertos conceptos asociados al proyecto como son la
Web Semántica y las Ontologías), hasta la planificación de cómo se ha desarrollado.
Asimismo, también cuenta al final con el anexo “Manual de Usuario” donde se
explicará detalladamente el uso de la aplicación web para el manejo de su
administración.

Los diferentes capítulos de los que consta esta memoria son:

1

1. INTRODUCCIÓN

 Definición del proyecto: Se explica qué es lo que se pretende conseguir con
este proyecto, es decir su objetivo, así como su alcance.

 Justificación: Cómo se justifica el desarrollo del proyecto. La razón por la cual
se ha realizado, así como los beneficios que puede aportar.

 Conceptos básicos: Definición y explicación de conceptos que ayudarán a
entender la documentación en su totalidad.

 Recursos utilizados: Qué recursos han sido utilizados para el desarrollo,
puesta en marcha y pruebas del proyecto.

 Diseño del proyecto: Una explicación a grandes rasgos de cómo está
organizado el proyecto, las ventanas que utiliza, etc. (mencionar que se
explicarán en más profundidad más adelante, en el anexo “Manual de
Usuario”).

 Desarrollo del proyecto: Cuál ha sido el desarrollo, cómo se ha organizado el
proyecto en el ámbito del desarrollo, componentes, etc.

 Usos alternativos: Qué usos alternativos se le pueden dar al proyecto además
del cual para el que ha sido creado en un primer momento, es decir, la
extracción/inserción de metadatos en páginas web.

 Planificación: Cuál ha sido el diario de planificación, diagramas de Gantt,
plazos establecidos, calendarios, etc.

 Conclusión: Conclusión global del proyecto, tanto en aprendizaje propio a lo
largo del recorrido como el aporte que supone el proyecto a la Web Semántica.

 Manual de usuario: Documento que explica cómo hacer uso de las herramientas
desarrolladas a nivel de usuario.

2


2. DEFINICIÓN DEL PROYECTO

2.1 OBJETIVOS
El proyecto está principalmente orientado a solucionar problemas que tienen
que ver con los metadatos, pese a que como veremos más adelante, también pueda
ser utilizado con otros fines. Uno de los objetivos es el de hacer que una página sin
metadatos pueda ser enriquecida con ellos. Debido a que el servidor se trata de un
servido proxy, en la práctica la página original no contendría los metadatos
introducidos, sino que el proxy al cual el usuario hace la petición de enriquecer la
página indicada por él/ella, tras combinar la página original con los metadatos a
insertar (que previamente han sido introducidos y almacenados en el propio servidor
proxy) devolverá al usuario una página casi idéntica a la original solo que enriquecida
con metadatos.

Por otra parte, también existe el problema de que a pesar de que algunas
páginas tienen metadatos, estos no están adecuadamente representados visualmente
dificultando su identificación y comprensión para los humanos. Por ello, otro de los
objetivos que se persiguen es el de poder extraer los metadatos de las páginas y
posteriormente, tras generar una página casi idéntica a la original, representarlos
visualmente en ella en un formato más cómodo de visualizar por el ser humano
(concretamente en formato XML y también a modo de grafo).

Así expuesta la situación, este proyecto persigue los siguientes objetivos:

 Investigación de las posibilidades que ofrece la Web Semántica en páginas sin
metadatos.

 Investigación de las posibilidades que ofrece la Web Semántica en las páginas
con metadatos.

 Documentación sobre el proyecto para posterior aprendizaje y puesta en
funcionamiento.

 Extracción de metadatos en páginas semantizadas.

 Añadir metadatos a páginas semantizadas y/o sin semantizar.

 Creación de una estructura flexible del servidor proxy donde el comportamiento
por defecto de éste (extracción y añadido de metadatos) no sea la única
posibilidad.

3


 Desarrollar un backend mediante el cual se pueda administrar y depurar
metadatos del proxy.

 Desarrollar una pequeña API para trabajar con metadatos.

2.2 ALCANCE

2.2.1 Alcance del proyecto

Los límites generales del proyecto son:

 Realización de una investigación sobre las tecnologías que mejor se adapten a
las necesidades del proyecto y posterior documentación.

 Implementación del proyecto con su backend de administración y depuración,
así como el servidor proxy.

 Implementación de varios scripts para diferentes páginas como prueba de
concepto y la redacción de una documentación adecuada que describa el
proyecto.

2.2.2 Alcance de la investigación

Los límites de la investigación son:

 Realización de una investigación sobre las tecnologías utilizadas en la Web
Semántica para la descripción de los contenidos, como RDF, OWL, RDFa o
GRDDL, además de SPARQL, el lenguaje de consulta más utilizado dentro de
la Web Semántica.

 Realización de una investigación sobre los pilares de la infraestructura, como
son el lenguaje de programación Python, el framework para la creación del
portal Django y las diferentes librerías usadas, las cuales se describirán más
adelante.

2.2.3 Alcance de la documentación

Los límites de la documentación son:

 Realización de una documentación donde se expliquen los conceptos básicos
necesarios para entender el proyecto, la herramienta (el servidor proxy) y la
documentación.

4


 Realización de una documentación donde se explique el funcionamiento de la
herramienta (el servidor proxy).

 Realización de una documentación donde se explique el proceso, así como las
diferentes tecnologías/herramientas utilizadas para el desarrollo del proyecto.

2.2.4 Alcance de la herramienta

Este proyecto tiene un alcance un tanto global, ya que ha sido diseñado de
forma que resulte lo más flexible posible. Esto último, hace posible que la mayor parte
las páginas existentes puedan aprovecharse de esta herramienta. Sin embargo, para
la realización de las pruebas de concepto pertinentes hemos seleccionado y hecho
uso de una serie de páginas específicas:

 Página personal de Dr. Diego López de Ipiña:

Esta página constituye la página principal sobre la cual se ha
experimentado con la extracción, manejo y representación tanto en XML como
en forma de grafo de metadatos. Más específicamente, se ha realizado una
extracción de RDFa mediante GRDDL, así como un análisis de archivos RDFa.

 Página personal de David Bujan:

En la página personal de David Buján se ha realizado una prueba de
concepto para demostrar que este proyecto no sólo vale para el añadido,
manejo y extracción de metadatos, sino para todo lo que se nos pueda ocurrir
como cambiar el estilo de una página por completo.

 Servidor propio para pruebas:

Al igual que la página de David Buján, en ésta se han hecho pruebas
diferentes a las de extracción/manejo de metadatos. Sin embargo, en un punto
del desarrollo también nos sirvió para experimentar con RDFa y GRDDL, así
como con diferentes ontologías.

2.3 PRODUCTO FINAL
Este proyecto va a dar lugar a un producto final que a su vez, se compone de
una serie de productos finales o herramientas:

 Backend:

o Administrador de usuarios.

5


o Administrador de las páginas que maneja el servidor proxy.

o Administrador de scripts.

 Depuración:

o Administrador de RDFs.

o Administrador de Ontologías.

o Consultas SPARQL.

 Proxy:

o Script por defecto para la extracción de metadatos (de modo que el
comportamiento por defecto de servidor proxy sea el
manejo/manipulación de metadatos).

o API flexible para modificar el comportamiento del proxy.

o Carga de scripts individuales e independientes para cada página.

2.4 DESCRIPCIÓN DE LA REALIZACIÓN

2.4.1 Método de desarrollo:

El método de desarrollo utilizado para este proyecto será el famoso método de
desarrollo por fases. El método de desarrollo por fases es muy efectivo cuando la
complejidad de un proyecto es alta. De esta forma el seguimiento, la corrección y la
organización es más fácil y requiere menos tiempo. Para ello se han definido las
siguientes fases:

 Análisis:

En esta fase se expondrá el problema principal, se analizará y se
buscará una solución. Para ello se limitará a los aspectos principales para el
planteamiento del problema dejando a un lado aquellos que resulten
irrelevantes y/o poco importantes. Asimismo, también se identificarán y
establecerán las entradas del problema, así como las salidas o resultados
deseados.

 Diseño:

En esta fase se diseñará una solución adecuada para solventar el
problema, por lo que constituye la parte más difícil del proceso de resolución

6


del problema. Es importante tener en cuenta la flexibilidad que se desea
conseguir, ya que la flexibilidad de la herramienta viene dada por un diseño
flexible.

 Implementación:

Esta etapa consiste en implementar o escribir el algoritmo como un
programa de computadora en un lenguaje de programación, convirtiendo cada
paso del algoritmo en instrucciones en el lenguaje de programación. Se
requiere el conocimiento de un lenguaje de programación particular en lo
referente a su gramática, sintaxis y semántica. Asimismo, se utilizarán los tipos
y estructuras de datos más adecuados y se intentará optimizar lo máximo
posible el rendimiento.

 Verificación y pruebas:

Esta fase consiste en probar la herramienta completa así como verificar
las pruebas realizadas para comprobar que realiza la función/tarea que se
esperaba. Para ello se necesitan datos y situaciones de prueba, que en nuestro
caso son páginas web para usar con el proxy, sobre los cuales ejecutar los
scripts verificando el correcto funcionamiento de estos últimos.

 Documentación:

Esta última etapa consiste en la redacción de una documentación del
proyecto en la que incluirán explicaciones e indicaciones de todo lo referente al
proyecto desarrollado: manuales, organización del proyecto, fases seguidas en
la realización del proyecto, tecnologías usadas, glosario, enlaces, etc.

2.4.2 Tareas principales:

A continuación se van a mostrar tareas principales. A su vez, cada tarea tiene
varias subtareas lo que hace que la tabla de tareas esté dividida correctamente y
facilite su lectura. Es importante recalcar que no todos los días se acumulaban 3 horas
de trabajo. En ocasiones se han llegado hasta las 10 horas de trabajo y muy pocas
veces la carga de trabajo diaria era inferior a las 3 horas.

7


Ilustración 2-1: Tabla de tareas

Por otra parte, el diagrama de Gantt asociado a las tareas es el siguiente:

8


Ilustración 2-2: Diagrama de Gantt

9


2.5 ORGANIZACIÓN Y EQUIPO
La organización del proyecto está formada por un comité de dirección, uno de
seguimiento y 2 grupos de trabajo como podemos ver en el siguiente esquema:

Ilustración 2-3: Esquema organizativo

 Comité de dirección:

Este comité tiene como misión ser el órgano que tome las decisiones en
el proyecto, y por tanto, sobre el cual recaerá la responsabilidad de dicho
proyecto. En en este caso en particular este organismo lo comforma el Dr.
Diego López de Ipiña.

 Comité de seguimiento:

Órgano ejecutivo del proyecto. Al igual que el comité de dirección, éste
también tomará decisiones y hará de representante de diferentes
departamentos. En en este caso en particular este organismo lo comforma el
Dr. Diego López de Ipiña.

 Grupo de trabajo:

Este grupo será el encargado del desarrollo del proyecto en sí. Su labor
consistirá en el desarrollo, instalación e implantación del sistema.

10


Se organizarán reuniones esporádicas (mensuales) para la toma de
decisiones, así como para comentar y llegar a soluciones para los diferentes
problemas que vayan surgiendo a raíz de la realización del proyecto.

En este caso en particular, seremos Iraide Diaz y Xabier Larrakoetxea
los que formemos este grupo.

Dentro del equipo de trabajo hay varios puestos diferentes y como se ha
comentado previamente todos estos puestos se han llevado a cabo por las mismas
personas. Es decir, las personas que han participado en este proyecto han tenido
varios puestos de trabajo diferentes dentro de la estructura organizativa a lo largo de
todo el proyecto. A continuación, se pueden observar los diferentes puestos existentes
dentro del equipo de trabajo.

 Equipo de trabajo

o Jefe de proyecto:

La tarea de este miembro es la de organizar y dirigir el equipo
encargado del proyecto, así como el de asegurarse el cumplimento de los
plazos.

o Ingenieros informáticos:

Desarrollarán la aplicación en su totalidad. Además de ello, se
encargarán también de hacer la configuración e implantación del sistema.

o Técnicos:

Podrían ser los mismos informáticos quienes realizaran el
mantenimiento del sistema, pero el hecho de tener un equipo técnico que
de apoyo a los ingenieros informáticos es importante. Su tarea será la de
mantener el servidor en perfecto funcionamiento en todo momento.

o Personal externo:

Pese a que no es un equipo de trabajo en sí, es importante recalcar
que siempre existirá un personal externo al proyecto. Este personal,
brindará ayuda y soporte en diferentes campos relacionados con el
proyecto, ya sea en una tecnología software como puede ser un IDE de
desarrollo o un lenguaje de programación, o tecnología hardware como
puede ser un PC en el puesto de servidor.

11


2.6 PRESUPUESTO
Las horas han sido variables durante el transcurso del proyecto, pero
aproximadamente las cantidades son las siguientes:

 Días laborables: 20días/mes
 Horas laborables: 5h/día

Perfil Carga Precio Importe

Jefe de proyecto 4 días 1.000€/mes 200€

Administrador/Técnico 15 días 800€/mes 600€

Programador 1 130 días 500€/mes 3.250€

Programador 2 130 días 500€/mes 3.250€

Total: 7.300,00€

2.7 CONDICIONES DE EJECUCIÓN
 Entorno de trabajo

Los lugares de trabajo donde se desarrollará el proyecto serán
principalmente las instalaciones de la facultad ESIDE de la Universidad de
Deusto: las diferentes aulas informáticas, los laboratorios de DeustoTech... Sin
embargo, debido a problemas de espacio o a otros motivos algunos de los
trabajos también podrán ser realizados desde las casas particulares de los
desarrolladores.

El calendario estará sujeto al hecho de que los desarrolladores son
alumnos de la facultad de Ingeniería de Deusto, con lo cual el horario será
bastante flexible dependiendo de las necesidades y los compromisos (horas de
clase, reuniones…) de los propios desarrolladores. Por tanto, no estarán
sujetos a un horario en particular siempre y cuando se cumplan las horas
acordadas previamente (15 horas semanales).

 Hardware

o 2 Ordenadores portátiles propiedad de los propios desarrolladores.

o 2 Ordenadores de sobremesa propiedad de los propios desarrolladores.

12


 Software

o Sistema Operativo GNU/Linux (distribuciones Arch Linux y Slackware).

o Entorno de desarrollo: Geany.

o Navegadores: Mozilla Firefox y/o Google Chrome.

o Control de versiones: Git.

 Control de cambios:

En el caso de existir alguna petición de modificación o ampliación en los
requisitos durante la realización el proyecto, ésta deberá estar sujeta a una
serie de directrices que deberán ser cumplidas:

1. Comunicación del/los cambio/s al jefe de proyecto.

2. Presentación de él/ellos al jefe de proyecto.

3. Análisis de los cambios por parte del jefe de proyecto y del comité
de seguimiento.

4. Emisión del veredicto y en caso de ser aprobado, modificación tanto
de la planificación como del proyecto en sí.

Las reuniones con los trabajadores podrán ser diarias o semanales,
mientras que las reuniones con el director de proyecto serán cada 3 semanas o
mensuales.

 Recepción de productos:

Tras terminar el desarrollo del proyecto y las pruebas del mismo, el
servidor será testeado por el jefe de proyecto y dará su aprobación. Una vez
aprobado, pasará por una serie de pruebas posteriores las cuales durarán 2
semanas. Tras este periodo de tiempo, se considerará que la herramienta es
estable y se procederá a su instalación.

Tras las pruebas, se procederá a crear una documentación detallada
sobre el proyecto (la cual posteriormente será guardada por el jefe de proyecto)
que incluirá como anexo un Manual de Usuario que explicará cómo utilizar y
configurar el servidor para enriquecer semánticamente páginas y manejar los
metadatos, así como para modificar el comportamiento por defecto del servidor
proxy posibilitando así la realización de otros trabajos/tareas por parte de éste.

13


3. CONCEPTOS BÁSICOS

3.1 PROXY
Un proxy pertenece a una red informática donde modifica el comportamiento y
la ruta de dicha red. Un proxy lo que hace es representar a otro objeto dentro de dicha
red.

Dicho de otra forma: Un proxy, en una red informática, es un programa o
dispositivo que realiza una acción en representación de otro, esto es, si una hipotética
máquina a solicita un recurso a una máquina c, lo hará mediante una petición a la
máquina b; c entonces no sabrá que la petición procedió originalmente de a. Su
finalidad más habitual es la de servidor proxy, que sirve para interceptar las
conexiones de red que un cliente hace a un servidor de destino, por varios motivos
posibles como seguridad, rendimiento o anonimato.

3.1.1 Tipos

 Forward proxies:

Ilustración 3-1: Ilustración de un forward proxy

Los forward proxies son proxies donde el cliente hace una llamada al
servidor externo al que quiere conectarse. Los forward proxies son capaces de
recuperar de una amplia gama de páginas. Los términos forward proxy y
forwarding proxy son una descripción general de la conducta (reenvío de
tráfico) y por lo tanto ambigua. A excepción del proxy inverso (reverse proxy),
cuando hablamos de proxies se suele hacer referencia al forward proxy.

 Open proxies:

15


Un proxy abierto u open proxy es un servidor proxy de reenvío que es
accesible por cualquier usuario de Internet. Este tipo de proxy permite a los
usuarios anónimos ocultar su dirección IP mientras navegan por la Web o usar
otros servicios de Internet.

Ilustración 3-2: Ilustración de un proxy abierto

 Reverse proxies:

Un proxy inverso es un servidor proxy que se a simple vista de los
clientes parece un servidor común. Las solicitudes se envían a uno o más
servidores de origen que atenderán la solicitud y la respuesta se devuelve
como si viniera directamente del servidor proxy, pero en realidad no es así.

Ilustración 3-3: Ilustración de un proxy inverso

Los reverse proxies están instalados en conjunto de uno o más
servidores Web. Todo el tráfico procedente de Internet y con un destino de uno
de los servidores web pasa a través del servidor proxy. El uso del “reverse” se
origina en el proxy, ya que el proxy inverso se encuentra más cerca del servidor
web y sirve sólo un conjunto limitado de sitios web, al contrario que otros tipos
de proxy.

Existen varios tipos de reverse proxy:

o Cifrado / Aceleración SSL

o Load balancing (repartir la carga)

o Servir/cachear contenido estático

16


o Compresión

o Spoon feeding

o Seguridad

o Extranet Publishing

3.1.2 Funcionamiento

Un proxy permite a otros equipos conectarse a una red de forma indirecta a
través de él. Cuando un equipo de la red desea acceder a una información o recurso a
través de éste, es realmente el proxy quien realiza la comunicación y a continuación
traslada el resultado al equipo inicial. En algunos casos, esto se hace de este modo ya
que no es posible la comunicación directa, mientras que en otros suele deberse a que
el proxy añade una funcionalidad adicional como puede ser la de almacenar los
últimos resultados obtenidos (p.ej.: una página web) en una caché que permita
acelerar sucesivas consultas coincidentes. Con esta denominación general de proxy
se agrupan diversas técnicas.

3.2 WEB SEMÁNTICA

3.2.1 Definición

La Web Semántica es una Web extendida, dotada de mayor significado en la
que cualquier usuario en Internet podrá encontrar respuestas a sus preguntas de
forma más rápida y sencilla gracias a una información mejor definida. Al dotar a la
Web de más significado y, por lo tanto, de más semántica, se pueden obtener
soluciones a problemas habituales en la búsqueda de información gracias a la
utilización de una infraestructura común, mediante la cual, es posible compartir,
procesar y transferir información de forma sencilla. Esta Web extendida y basada en el
significado, se apoya en lenguajes universales que resuelven los problemas
ocasionados por una Web carente de semántica en la que, en ocasiones, el acceso a
la información se convierte en una tarea difícil y frustrante. Para ello, se apoya en
ciertas herramientas y técnicas como pueden ser las ontologías.

3.2.2 Utilidades

La Web Semántica ha cambiado la forma en la que navegamos. A simple vista
la Web Semántica no parece estar ahí, pero su presencia es muy importante. En la
comunicación que vemos en Internet normalmente la Web Semántica está de por
medio ya que las páginas están interconectadas y tienen datos “extra” (metadatos) que

17


nosotros no reconocemos o percibimos, pero que ciertas herramientas software (tales
como los buscadores) que los necesitan, lo usan para llevar a cabo sus tareas.

La Web ha cambiado significativamente la forma en la que nos comunicamos,
hacemos negocios e incluso trabajamos. Gracias a ella tenemos acceso a millones de
recursos en cualquier momento, independientemente de nuestra situación geográfica e
idioma. Si bien es cierto que estos factores han contribuido al éxito de la Web. Sin
embargo, al mismo tiempo, estos factores que han propiciado el éxito de la Web,
también han originado sus principales problemas: sobrecarga de información y
heterogeneidad de fuentes de información con el consiguiente problema de
interoperabilidad.

La Web Semántica trata de resolver estos los problemas descritos permitiendo
a los usuarios delegar tareas en software. Gracias a la semántica en la Web, ahora las
herramientas software pueden procesar su contenido, razonar y realizar deducciones
lógicas de tal forma que las resoluciones a problemas cotidianos se automatizan y se
consiguen resultados más exactos.

Existen ciertos escenarios en los que la Web Semántica puede ayudar a
solucionar problemas o ayudar con la realización de ciertas tareas. Como ejemplos
tenemos:

 Búsquedas en internet (por ejemplo, para llevar a cabo búsquedas más
precisas y exhaustivas con un buscador como Google).

 Obtención de datos desde una aplicación móvil (por ejemplo, capturar posición
de mapas en una aplicación para Android).

 Interconexión de Webs (por ejemplo, para conectar páginas personales de los
profesores de una universidad).

3.2.3 Funcionamiento

18


Ilustración 3-4: Estructura de la web semántica

Para obtener una adecuada definición de los datos, la Web Semántica hace
uso de varias tecnologías y mecanismos:

 RDF:

El Marco de Descripción de Recursos (del inglés Resource Description
Framework, RDF) es un framework para metadatos en la World Wide Web
(WWW), desarrollado por el World Wide Web Consortium (W3C). Proporciona
información descriptiva sobre los recursos que se encuentran en la Web y que
se utiliza, por ejemplo, en catálogos de libros, directorios, música, proyectos,
documentos, etc.

 OWL (Ontologías):

OWL es el acrónimo del inglés Ontology Web Language, un lenguaje de
marcado para publicar y compartir datos usando ontologías en la WWW. OWL
tiene como objetivo facilitar un modelo de marcado construido sobre RDF y
codificado en XML. Como definición simple se podría decir que lo que hace
OWL es proporcionar un lenguaje para definir ontologías estructuradas que
pueden ser utilizadas a través de diferentes sistemas.

 SPARQL:

SPARQL es un acrónimo recursivo del inglés SPARQL Protocol and
RDF Query Language. Se trata de un lenguaje estandarizado para la consulta
de grafos RDF que permite hacer búsquedas sobre los recursos de la Web
Semántica utilizando distintas fuentes de datos.

19


3.3 ONTOLOGÍAS
Dentro de la informática cuando nos referimos a ontologías, se hace referencia
a la formulación de un exhaustivo y riguroso esquema conceptual dentro de un
dominio dado, para conseguir un intercambio de información más coherente y fácil
entre diferentes sistemas.

Un uso común tecnológico actual del concepto de ontología, en este sentido
semántico, lo encontramos en la inteligencia artificial y la representación del
conocimiento. En algunas aplicaciones, se combinan varios esquemas en una
estructura de facto completa de datos, que contiene todas las entidades relevantes y
sus relaciones dentro del dominio.

Ilustración 3-5: Ejemplo de ontología

Los programas informáticos pueden utilizar así este punto de vista de la
ontología para una variedad de propósitos, incluyendo el razonamiento inductivo, la
clasificación, y una variedad de técnicas de resolución de problemas.

Para definir estas ontologías existen actualmente lenguajes o más bien
estándares (W3C) que lo posibilitan como es el caso de OWL.

20


3.4 SPARQL
SPARQL (SPARQL Protocol and RDF Query Language) es un lenguaje
estandarizado para la consulta de grafos RDF que permite hacer búsquedas sobre los
recursos de la Web Semántica utilizando distintas fuentes de datos. Básicamente
SPARQL sería de la misma forma que SQL es para los datos comunes, pero orientado
a la web semántica. Esto significa que SPARQL es la forma que existe para hacer
consultas en una base de datos donde previamente han sido almacenados metadatos.

Al igual que sucede con SQL, es necesario distinguir entre el lenguaje de
consulta y el motor para el almacenamiento y recuperación de los datos. Por este
motivo, existen múltiples implementaciones de SPARQL, generalmente ligados a
entornos de desarrollo y plataformas tecnológicas.

En un principio SPARQL únicamente incorpora funciones para la recuperación
de sentencias RDF. Sin embargo, algunas propuestas también incluyen operaciones
para el mantenimiento (creación, modificación y borrado) de datos.

3.5 LINKED DATA
Los Datos Enlazados es la forma que tiene la Web Semántica de vincular los
distintos datos que están distribuidos en la Web, de forma que se referencian de la
misma forma que lo hacen los enlaces de las páginas web.

De la misma forma que la web de la web del hipertexto, la web de los datos se
construye mediante documentos en la web. Sin embargo, y a diferencia de la web del
hipertexto, donde los enlaces son relaciones entre puntos de los documentos escritos
en HTML, los datos enlazan cosas arbitrarias que se describen en RDF.

Los datos publicados en la Web se pueden vincular a otros, de forma que las
personas y las máquinas puedan explorar la web de los datos, pudiendo llegar a
información relacionada que se hace referencia desde otros datos iniciales. Por tanto,
Linked Data permite construir la Web de los datos, es decir, una gran base de datos
interconectados y distribuidos en la Web, lo cual los vuelve más útiles.

Los Datos Enlazados, como parte de la Web Semántica, se basa en la
aplicación de ciertos principios básicos y necesarios, que fomentarán el crecimiento de
la Web, tanto a nivel de los documentos HTML (vista clásica de la Web), como a nivel
de los datos expresados en RDF (vista de la Web Semántica). Sir Tim Berners-Lee
definió cuatro principios que caracterizan los datos vinculados en su ponencia de
presentación para el W3C.

21


1. Utilizar URIs para identificar los recursos publicados en la Web.
2. Aprovechar el HTTP de la URI para que la gente pueda localizar y consultar (es
decir, desreferenciar) estos recursos.
3. Proporcionar información útil acerca del recurso cuando la URI haya sido
desreferenciada.
4. Incluir enlaces a otras URI relacionadas con los datos contenidos en el recurso,
de forma que se potencie el descubrimiento de información en la Web.

Ilustración 3-6: Conjunto de datos interconectados entre sí que componen la "Nube de Linked
Data"

Para conseguir tener los datos interconectados y consecuentemente poder
permitir reutilizar la información de cualquier manera esperada o inesperada
(ofreciendo un valor añadido a la Web), se deben respetar los cuatro pasos anteriores.

3.6 EXPRESIONES REGULARES
Una expresión regular, a menudo llamada también patrón, es una expresión
que describe un conjunto de cadenas sin enumerar sus elementos. Por ejemplo, el
grupo formado por las cadenas Handel, Händel y Haendel se describe mediante el
patrón "H(a|ä|ae)ndel". La mayoría de las formalizaciones proporcionan los siguientes
constructores: una expresión regular es una forma de representar a los lenguajes
regulares (finitos o infinitos) y se construye utilizando caracteres del alfabeto sobre el

22


cual se define el lenguaje. Específicamente, las expresiones regulares se construyen
utilizando los operadores unión, concatenación y clausura de Kleene. Además cada
expresión regular tiene un autómata finito asociado.

En el área de la programación, las expresiones regulares son un método por
medio del cual se pueden realizar búsquedas dentro de cadenas de caracteres. Sin
importar si la búsqueda requerida es de dos caracteres en una cadena de 10 o si es
necesario encontrar todas las apariciones de un patrón definido de caracteres en un
archivo de millones de caracteres, las expresiones regulares proporcionan una
solución para el problema. Adicionalmente, un uso derivado de la búsqueda de
patrones es la validación de un formato específico en una cadena de caracteres dada,
como por ejemplo fechas o identificadores.

Para poder utilizar las expresiones regulares al programar es necesario tener
acceso a un motor de búsqueda con la capacidad de utilizarlas. Es posible clasificar
los motores disponibles en dos tipos:

Motores para el usuario final

Son programas que permiten realizar búsquedas sobre el contenido de un
archivo o sobre un texto extraído y colocado en el programa. Están diseñados para
permitir al usuario realizar búsquedas avanzadas usando este mecanismo. Sin
embargo es necesario aprender a redactar expresiones regulares adecuadas para
poder utilizarlos eficientemente. Éstos son algunos de los programas disponibles:

 grep: programa de los sistemas operativos Unix/Linux.
 PowerGrep: versión de grep para los sistemas operativos Windows.
 RegexBuddy: ayuda a crear las expresiones regulares en forma interactiva y
luego le permite al usuario usarlas y guardarlas.
 EditPad Pro: permite realizar búsquedas con expresiones regulares sobre
archivos y las muestra por medio de código de colores para facilitar su lectura y
comprensión.

Motores para el programador

Permiten automatizar el proceso de búsqueda de modo que sea posible
utilizarlo muchas veces para un propósito específico. Estas son algunas de las
herramientas de programación disponibles que ofrecen motores de búsqueda con
soporte a expresiones regulares:

 Java: existen varias bibliotecas hechas para java que permiten el uso de
RegEx, y Sun planea dar soporte a estas desde el SDK
 JavaScript: a partir de la versión 1.2 (ie4+, ns4+) JavaScript tiene soporte
integrado para expresiones regulares.
 Perl: es el lenguaje que hizo crecer a las expresiones regulares en el ámbito
de la programación hasta llegar a lo que son hoy en día.

23


 PCRE: biblioteca de ExReg para C, C++ y otros lenguajes que puedan utilizar
bibliotecas dll (Visual Basic 6 por ejemplo).
 PHP: tiene dos tipos diferentes de expresiones regulares disponibles para el
programador, aunque la variante POSIX (ereg) va a ser desechada en PHP 6.
 Python: lenguaje de "scripting" popular con soporte a Expresiones Regulares.
 .Net Framework: provee un conjunto de clases mediante las cuales es posible
utilizar expresiones regulares para hacer búsquedas, reemplazar cadenas y
validar patrones.

En Python las expresiones regulares tienen una sintaxis la cual podemos
apreciar en la siguiente tabla. Cabe mencionar que no se trata de la tabla completa, ya
que es muy amplia, pero se puede ver lo más importante:

Patrón Descripción

^ Principio de linea

$ Final de linea

Cualquier character salvo cambio de linea (con la opción m adopta
.
también cambio de linea)

[...] Cualquier character dentro de los corchetes

[^...] Cualquier character diferente dentrod e los corchetes

re* 0 o más ocurrencias

re+ 1 o más ocurrencias

re? 0 o 1 ocurrencias

re{ n} Exactamente “n” ocurrencias

re{ n,} N o más ocurrencias

24


re{ n, m} De n a m ocurrencias

a| b Aob

(re) Agrupa expresiones regulares

Temporalmente activa las opciones I, m, o x en una expresión
(?imx)
regular dentro del parentesis

Temporalmente desactiva las opciones I, m, o x en una expresión
(?-imx)
regular dentro del parentesis

(?: re) Agrupa expresiones regulares sin memorizar la ocurrencia del texto

(?imx: re)
regular

(?-imx: re)
regular

(?#...) Comentarío

(?= re) Posición especifica dentro del patron. No tiene rango

(?! re) Posición especifica dentro del patrón negado. No tiene rango.

(?> re) Asocia un patron independiente sin usar “Backtracking”

w Asocia caracteres de palabras

W Asocia caracteres de “no palabras”

s Asocia espacios en blanco. Equivalente a [tnrf].

25


S Asocia no espacios en blanco

d Asocia dígitos. Equivalente a [0-9].

D Asocia “no dígitos”

A Asocia principio de un string (cadena de caracteres)

Asocia final de un string.Si existe una nueva linea, lo asocial justo
Z
hasta el comienzo de

z Asocia final de un string

G Asocia la posición en la qu ese encotrntro la última asociación

Un ejemplo de uso de expresiones regulares en Python sería este pequeño
snippet de código. Lo que hace es buscar el patron “<body>” indicándole que después
de “<body>” y antes de “>” puede haber: espacios, =, “ o caracteres.

import re

regularExpressionIn = '<body[w"= ]*>'
reg = re.compile(regularExpressionIn)
m = reg.search(body)

Código 3-1: Ejemplo de expresión regular en Python

3.7 GRDDL
GRDDL son las siglas de Gleaning Resource Descriptions from Dialects of
Languages o en castellano: "Espigar Descripciones de Recursos de Dialectos de
Lenguajes". Una explicación sencilla para GRDDL sería tan simple como “un extractor
de metadatos”. Sin embargo, no es tan simple como parece.

26


GRDDL es una forma de indicar una transformación, comúnmente mediante
XSLT, de un documento XHTML o XML para obtener información en RDF. Mediante
esta indicación, una aplicación informática puede extraer de forma automática
información de páginas web estructuradas para integrarla en la Web Semántica.

3.7.1 Ejemplo con XHTML

Un documento especifica transformaciones asociadas usando varias formas.
Por ejemplo un document XHTML puede contener lo siguiente:

<head profile="http://www.w3.org/2003/g/data-view
http://dublincore.org/documents/dcq-html/
http://gmpg.org/xfn/11">

<link rel="transformation" href="grokXFN.xsl" />

Código 3-2: Declaración de transformación GRDDL en XHTML

En el argumento “profile” se da a conocer que este documento tiene
transformación mediante GRDDL, en concreto en “http://www.w3.org/2003/g/data-view”.
La transformación se hará mediante el atributo “transformation” que apuntará a la hoja
XSL (en este caso grokXFN.xsl ) que marcará la forma en la que se extraerá la
información.

Cabe destacar que este código es valido para XHTML 1.x, ya que en HTML el
atributo “profile” ha sido eliminado.

3.7.2 Microformatos

Por otra parte, una página puede contener microformatos. Para ello, se
necesita un perfil (profile) específico que marcará la forma en la que se extraen datos
del documento.

Por ejemplo, un documento que tiene hcard mediante microformatos debería
de tener lo siguiente en su cabecera:

<head profile="http://www.w3.org/2003/g/data-view
http://www.w3.org/2006/03/hcard">

Código 3-3: Declaración de transformación GRDDL para hcard con Microformatos

Dentro de ese link a hcard tenemos:

<head profile="http://www.w3.org/2003/g/data-view">

27


Código 3-4: Profile de GRDDL dentro de hcard

Y por último:

<p>Use of this profile licenses RDF data extracted by
<a rel="profileTransformation"
href="../vcard/hcard2rdf.xsl">hcard2rdf.xsl</a>
from <a href="http://www.w3.org/2006/vcard/ns">the 2006
vCard/RDF work</a>.
</p>

Código 3-5: Datos de hcard conteninedo el XSL para transformar microformatos hcard en GRDDL

28


4. JUSTIFICACIÓN
La realización de este proyecto está ligada a la necesidad de que cada vez
más páginas están convirtiéndose a páginas web semantizadas (es decir, páginas con
metadatos). A día de hoy, un gran porcentaje de páginas web tiene metadatos que a
simple vista el humano no puede ver sin usar herramientas externas, por ello una
solución sería la fácil extracción de metadatos.

4.1 BENEFICIOS TÉCNICOS
Los beneficios técnicos son bastante altos. En primer lugar debemos tener en
cuenta que necesitamos una extracción o introducción de metadatos. Eso aportaría un
valor en tiempo y esfuerzo. Por ejemplo, una empresa requiere un análisis de los RDF
que actualmente su página trata. Con el esta herramienta la visualización de esos
metadatos sería rápida y sin tener que hacer un despliegue grande de herramientas y
recursos.

Por otra parte, si una vez analizados los metadatos se quisiera realizar una
inserción de metadatos rápida, ésta se podría hacer mediante el propio servidor proxy
tras modificar su funcionamiento mediante un script. Esto permitiría ver los nuevos
metadatos en la página, pero sin embargo, no serían cambios definitivos. De esta
forma, podríamos pasar a hacerlos permanentes, haciendo las modificaciones
pertinentes en la página original y el servidor. Así la inserción de metadatos mediante
el servidor proxy se podría hacer como prueba antes de hacerlo definitivo.

Asimismo, como un efecto no orientado a la web semántica y ligado al cambio
de funcionamiento del servidor proxy mediante scripts, también se podría usar el proxy
para cambiar el aspecto e incluso el comportamiento de una página.

4.2 BENEFICIOS ECONÓMICOS
Los beneficios económicos no son tan claros como los técnicos. La herramienta
en sí, aportaría beneficio del tipo de ahorro en tiempo, herramientas y personal, que
traducido en términos económicos sería un ahorro alto al no tener que hacer uso de
esos recursos. A esto se le puede sumar que el aprendizaje de uso de la herramienta
es sencillo e intuitivo y no requiere mucha preparación para su manejo, por tanto, los
gastos derivados de la formación en el uso de la herramienta tampoco serían muy
altos.

29


5. INVESTIGACIÓN EN TECNOLOGÍAS

5.1 VISIÓN GENERAL
En este capítulo se van a explicar las diferentes tecnologías utilizadas en el
desarrollo del Proyecto, las cuales se expondrán de forma teórica y explicativa así
como algún ejemplo práctico de ellas.

5.2 RECURSOS PRINCIPALES

5.2.1 Python

Ilustración 5-1: Logo de Python

Python es un lenguaje de programación, interpretado, rápido y flexible. Cada
año gana nuevos adeptos y es de los lenguajes más utilizados actualmente. Es un
lenguaje de alto nivel cuya filosofía hace hincapié en una sintaxis muy limpia y que
favorezca un código legible.

Se trata de un lenguaje de programación multiparadigma ya que soporta
orientación a objetos, programación imperativa y, en menor medida, programación
funcional. Es un lenguaje interpretado, usa tipado dinámico, es fuertemente tipado y
multiplataforma.

Es administrado por la Python Software Foundation. Posee una licencia de
código abierto, denominada Python Software Foundation License, que es compatible
con la Licencia pública general de GNU a partir de la versión 2.1.1, e incompatible en
ciertas versiones anteriores.

31


5.2.1.1 Tipos de datos

Los tipos de datos que existen en este lenguaje, estos se pueden resumir en la
siguiente tabla:

Tipo Clase Notas Ejemplo

str Cadena Inmutable 'Cadena'

unicode Cadena Versión Unicode de str u'Cadena'

Mutable, puede contener objetos
list Secuencia [4.0, 'Cadena', True]
de diversos tipos

Inmutable, puede contener
tuple Secuencia (4.0, 'Cadena', True)
objetos de diversos tipos

Mutable, sin orden, no contiene set([4.0, 'Cadena',
set Conjunto
duplicados True])

Inmutable, sin orden, no frozenset([4.0,
frozenset Conjunto
contiene duplicados 'Cadena', True])

{'key1': 1.0, 'key2':
dict Mapping Grupo de pares clave:valor
False}

Número Precisión fija, convertido en long
int 42
entero en caso de overflow.

Número 42L ó
long Precisión arbitraria
entero 456966786151987643L

Número
float Coma flotante de doble precisión 3.1415927
decimal

bool Booleano Valor booleano verdadero o falso True o False

32


5.2.1.2 Ejemplo práctico

A modo de ejemplo práctico, en las siguientes líneas se va a mostrar un
pequeño programa desarrollado en Python con su correspondiente resultado devuelto
por pantalla.

En primer lugar, un ejemplo de una función (que en este caso calcula el
factorial) escrita en este lenguaje podría ser el siguiente:

def factorial(x):
if x == 0:
return 1
else:
return x * factorial(x - 1)

Código 5-1: Ejemplo de una función en Python

Asimismo, Python al igual que muchos lenguajes de programación es orientado
a objetos. En el siguiente bloque de código, se declara una clase y luego se llama al
objeto:

class Test:

def __init__(self, x, y):
self._x = x
self._y = y

def _suma(self):
return self._x + self._y

def suma(self):
return self._suma()

Código 5-2: Ejemplo de una clase en Python

En el bloque de código que viene a continuación se pueden ver la combinación
de los dos ejemplos anteriores en un script (o programa) de Python. La función
factorial se encuentra en un archivo llamado factorial.py y la clase Test en un
archivo llamado pythonTestClass.py:

from pythonTestClass import Test
from factorial import factorial

t = Test(1,3)
x = t.suma()
print factorial(x)

33


Código 5-3 Ejemplo de un script (programa) en Python

Finalmente, tras la ejecución del anterior bloque de código, en las siguientes
líneas se muestra el resultado obtenido por línea de comandos (Python es un lenguaje
interpretado y por tanto, los programas realizados en este lenguaje se podrían ejecutar
directamente escribiéndolos en la línea de comandos propia de Python, no siendo
necesaria la escritura de un script/programa (fichero), pese a que esto último sea lo
más común.)

slok@sLoKPC:pythonPFCDoc$ python ./test.py
11
24

Código 5-4 Resultado del ejemplo anterior

5.2.1.3 Integración con el proyecto

En lo que a respecta al uso de Python dentro del proyecto, mencionar que todo
el código del proyecto ha sido escrito en este lenguaje. Es más, incluso el propio
código HTML del portal para el manejo del servidor proxy ha sido desarrollado
mediante Python, usando para ello el Framework de Desarrollo Django.

Las razones por las que se ha elegido este lenguaje de programación se
podrían resumir en varios puntos:

 Es un lenguaje muy flexible.
 El lenguaje es interpretado, por tanto, es fácil de poner en marcha.
 Tiene muchas y muy buenas librerías incluidas (como cita un slogan de Python:
“¡Con baterías incluidas!”), además de existir una cantidad mayor de librerías
escritas por terceros.
 Tiene gran cantidad de documentación de excelente calidad, algo que para el
aprendizaje y un buen desarrollo es muy importante.
 La curva de aprendizaje es corta.
 Cada vez se usa más este lenguaje.
 Es de los lenguajes que más potencia tiene (o que se le puede sacar).
 Su sintaxis es muy clara, ya que requiere que se tabule obligatoriamente.
 Soporta objetos, clases abstractas, encapsulación…
 Es una tecnología nueva para nosotros. Para el desarrollo del proyecto
decidimos utilizar algo nuevo que no supiéramos manejar de antemano (es
decir, que no hubiéramos visto a lo largo de la carrera), de modo que
constituiría una muy buena ocasión para aumentar nuestro conocimiento
(consideramos que el aprender nuevas cosas dentro del oficio de un Ingeniero
Informático, es algo importante).
 Es multiplataforma
 Es software libre

34


5.2.2 Django

Ilustración 5-2: Logo Django

Después de haber elegido Python como lenguaje de programación para el
proyecto, era necesario elegir el framework con el que se iba a desarrollar el portal
web. Para Python existen muchas opciones principales:

 Django
 Web2Py
 Pylons
 Turbogears
 WebPy

De todas ellas la elegida fue Django, por las siguientes razones:

 Flexible, al igual que Python.
 Tienen filtros que hacen muchos trabajos de manera automatizada.
 Amplia documentación disponible.
 Estable.
 Muchas webs famosas lo usan.
 Rápida puesta en marcha.
 Funcionamiento excelente con servidores de producción (Apache, Nginx…).
 Administrador de Django excelente (para la administración de usuarios,
grupos…).
 Muy rápido.
 Es multiplataforma (sobre python)
 Es software libre.

Django es un framework de desarrollo web de código abierto, escrito en
Python, que cumple en cierta medida el paradigma del Modelo Vista Controlador
(MVC). Fue desarrollado en origen para gestionar varias páginas orientadas a noticias
de la World Company de Lawrence, Kansas, y fue liberada al público bajo una licencia
BSD en julio de 2005.

35


La meta fundamental de Django es facilitar la creación de sitios web complejos.
Django pone énfasis en el re-uso, la conectividad y extensibilidad de componentes, el
desarrollo rápido y el principio “No te repitas” (DRY, del inglés Don't Repeat Yourself).
Python es usado en todas las partes del framework, incluso en configuraciones,
archivos, y en los modelos de datos.

5.2.2.1 Características

Entre las características/herramientas que dispone Django, aparte de las
previamente comentadas, existen muchas otras:

 Un mapeador objeto-relacional.
 Aplicaciones "enchufables" que pueden instalarse en cualquier página
gestionada con Django.
 Una API de base de datos robusta.
 Un sistema incorporado de "vistas genéricas" que ahorra tener que escribir la
lógica de ciertas tareas comunes.
 Un sistema extensible de plantillas basado en etiquetas, con herencia de
plantillas.
 Un despachador de URLs basado en expresiones regulares.
 Un sistema middleware para desarrollar características adicionales; por
ejemplo, la distribución principal de Django incluye componentes middleware
que proporcionan cacheo, compresión de la salida, normalización de URLs,
protección CSRF y soporte de sesiones.
 Soporte de internacionalización, incluyendo traducciones incorporadas de la
interfaz de administración.
 Documentación incorporada accesible a través de la aplicación administrativa
(incluyendo documentación generada automáticamente de los modelos y las
bibliotecas de plantillas añadidas por las aplicaciones).

Pese a que Django se trata de un framework de Modelo Vista Controlador, en
realidad se caracteriza por otro nombre ya que difiere un poco de lo que comúnmente
se tiene en mente, aunque en el fondo sea lo mismo. Esta característica es una de las
que hace especial a Django sobre otros frameworks. Como cita la Wikipedia:

“Aunque Django está fuertemente inspirado en la filosofía de desarrollo Modelo
Vista Controlador, sus desarrolladores declaran públicamente que no se sienten
especialmente atados a observar estrictamente ningún paradigma particular, y en
cambio prefieren hacer "lo que les parece correcto". Como resultado, por ejemplo, lo
que se llamaría "controlador" en un "verdadero" framework MVC se llama en Django
"vista", y lo que se llamaría "vista" se llama "plantilla".

Gracias al poder de las capas mediator y foundation, Django permite que los
desarrolladores se dediquen a construir los objetos Entity y la lógica de presentación y
control para ellos.”

36


Para poder usar Django, tan sólo es necesario tener instalado Python. Con
esto, Django podría funcionar perfectamente ya que trae consigo un servidor de
desarrollo (no apto para producción) y Sqlite3. En cuanto a otras BD, Django también
soporta MySQL, PostgreSQL y Oracle.

5.2.2.2 Funcionamiento

El flujo que sigue Django es algo particular. En la siguiente imagen y su
respectiva explicación se ve claramente cómo actúa Django:

Ilustración 5-3: Flujo

1. El servidor que sirve la página creada con Django recibe la petición del cliente
2. Esta petición es mapeada con el URL Dispatcher (urls.py) y llama a las
funciones que sean necesarias (views.py) que previamente hayan sido
asignadas o si se tiene una versión cacheada, esta será la que se devolverá en
vez de llamar a la función.
3. Una vez se está ejecutando el código de la función definida en views.py se
suelen hacer operaciones de escritura y lectura en bases de datos (aunque en
ocasiones no se hace y se ejecutan otras acciones). Para ello los modelos de
la base de datos se especifican en models.py.
4. A continuación la vista lo último que hará será pasar el paquete HTTP que será
devuelto, para ello lo suele pasar los datos por la template o plantilla.
5. El/los paquete(s) se envía a su destinatario.

37


5.2.2.3 Estructura

La estructura de un proyecto de Django es muy limpia y flexible. Utiliza el
concepto de apps (aplicaciones) y proyectos de diferente forma. En otros frameworks
significan lo mismo, pero para Django una aplicación y un proyecto no son lo mismo.
Un proyecto contiene muchas aplicaciones, esas aplicaciones son reutilizables en
otros proyectos y por eso tienen sus propios archivos de mapeadores de URL, vistas
(funciones), modelos de base de datos, etc. aparte de los del proyecto en sí. Por
ejemplo, puede haber dos archivos urls.py: uno el del proyecto y otro el de una
aplicación dentro del proyecto.

En la imagen que se muestra a continuación se ve claramente la estructura de
un proyecto de Django (la imagen pertenece al explorador de archivos que trae el IDE
Eclipse):

Ilustración 5-4: Estructura de un proyecto en Django

Una explicación a la imagen superior:

 La raíz del proyecto es simple_django (dentro del directorio /src). Ésta
contiene un fichero llamado __init__.py que es necesario por toda
aplicación de Python (para poder ejecutarlo) y puesto que Django está
completamente hecho en Python, éste también lo necesita.
 El fichero manage.py que será con el que se interactuará para poder arrancar
la aplicación (servidor de desarrollo), crear la estructura de base de datos en la
base de datos, etc.
 Settings.py contendrá toda la configuración del proyecto. Este fichero
contiene cosas tales como las rutas hacia las plantillas o templates, la ruta al
contenido estático (imágenes, sonidos, JavaScript…), la zona horaria,
contraseña de la base de datos etc.
 Urls.py será el mapeador donde se especificará hacia donde tendrá que ir
Django después de recibir una petición con una determinada URL. Un ejemplo
de este archivo sería el siguiente:

38

Memoria pfc, Metaproxy documentation

Memoria pfc, Metaproxy documentation

Recomendados

Recomendados

Más contenido relacionado

Similar a Memoria pfc, Metaproxy documentation

Similar a Memoria pfc, Metaproxy documentation (20)

Último

Último (20)

Memoria pfc, Metaproxy documentation