Talleres¶
La documentación de los talleres muestra algunos ejemplos de cómo utilizar GeoNode-Project para ampliar o personalizar las funcionalidades de GeoNode según tu negocio. Los temas tratados incluyen los siguientes:
1- Personaliza tu GeoNode con geonode-project
2- Personaliza la apariencia y el diseño
3- Crea los metadatos de tu ResourceBase
4- Crea tu propia aplicación Django
5- Añade un modelo personalizado
6- Permisos y APIs
7- Implementa tu GeoNode
1- Personaliza tu GeoNode con geonode-project¶
En este ejemplo, se clona GeoNode-Project para crear una instancia de plantilla sobre la cual se construirán el resto de los ejemplos.
1- Suponiendo que ya hayas instalado GeoNode-Core, primero debemos crear una plantilla GeoNode-Project y esto se puede lograr con el siguiente comando:
$ django-admin.py startproject my_geonode --template=https://github.com/GeoNode/geonode-project/archive/master.zip -e py,rst,json,yml,ini,env,sample -n Dockerfile
Aquí, se utiliza django-admin con la opción startproject para crear el proyecto my_geonode copiando la plantilla que se pasa como repositorio de Github de GeoNode-project. También incluye las extensiones «py,rst,json,yml,ini,env,sample»
2- Una vez finalizada la clonación, el siguiente paso es instalar el GeoNode-Project que acabamos de descargar de la siguiente manera:
$ pip install -e my_geonode
3- Instala geoserver usando paver de la siguiente manera
$ cd /home/geonode/my_geonode/src
$ paver setup
4- Ten en cuenta los parámetros de conexión a la base de datos GeoNode mencionados en el archivo .env.sample.py. Cambia el nombre a .env y luego utiliza psql para crear el usuario requerido y otorgar los privilegios necesarios de la siguiente manera:
$ su postgres
$ createdb geonode
$ psql
postgres=# CREATE USER geonode WITH PASSWORD 'geonode';
CREATE ROLE
postgres=# GRANT ALL PRIVILEGES ON DATABASE "geonode" to geonode;
GRANT
postgres=# \q
Advertencia
No olvides salir del usuario postgres antes de ejecutar los siguientes comandos
5- Ejecutar GeoNode usando paver
$ cd /home/geonode/my_geonode/src
$ paver start
Nota
Es posible que aparezca este mensaje de advertencia: You have 132 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): account, actstream, admin, agon_ratings, announcements, auth, avatar, base, contenttypes, dialogos, documents, favorite, geonode_client, geonode_themes, groups, guardian, invitations, layers, maps, mapstore2_adapter, monitoring, oauth2_provider, people, pinax_notifications, services, sessions, sites, socialaccount, taggit, tastypie, upload, user_messages. Esto significa que tienes algunas sentencias SQL que aún no se han ejecutado y necesitas ejecutar «migrate» para sincronizar tu base de datos primero y luego «paver start» nuevamente de la siguiente manera:
$ python manage.py migrate
$ paver start
Advertencia
Si aparece este mensaje: (Invalid HTTP_HOST header: '0.0.0.0:8000'. You may need to add u'0.0.0.0' to ALLOWED_HOSTS) Se puede solucionar en el archivo settings.py. Deberás agregar: ALLOWED_HOSTS = ['0.0.0.0'] en settings.py
6- Una vez realizado el paso anterior, puedes visitar 0.0.0.0:8000 para ver la GUI de GeoNode. Sin embargo, aún no tenemos una cuenta para iniciar sesión desde la GUI. Esto se puede hacer usando «paver sync». El comando creará una sincronización con los últimos dispositivos y también creará un superusuario «admin» con la contraseña predeterminada «admin».
7- Utiliza la cuenta creada para iniciar sesión desde la GUI a través de localhost:8000 o 0.0.0.0:8000
2- Personaliza la apariencia y el diseño¶
En esta sección, cambiaremos la apariencia de GeoNode. En particular, realizaremos algunas personalizaciones para ayudar a comprender cómo funciona la herencia de plantillas y cómo agregar elementos nuevos a tu GeoNode. Los cambios incluirán la página de inicio, el menú superior, el pie de página y una página genérica de GeoNode.
Página principal:
GeoNode-project proporciona algunas plantillas predefinidas para cambiar la página de inicio y el contenido general del sitio.
En el directorio «my_geonode/src/my_geonode/templates/geonode-mapstore-client/snippets» podemos encontrar archivos con nombres similares a geonode-mapstore-client. De esta manera podemos sobrescribir las diferentes partes del sitio, por ejemplo, el encabezado, el menú, el contenido del cuerpo y el pie de página.
Crea un archivo llamado hero.html y agrega lo siguiente.
<div id="gn-hero" class="gn-hero">
<div class="jumbotron">
<div class="gn-hero-description">
<h1>My GeoNode</h1>
<p>Example customization of geonode project</p>
</div>
<p class="gn-hero-tools"></p>
</div>
</div>
El tema:
Para cambiar el tema de nuestro GeoNode-project podemos actuar sobre el archivo site_base.css disponible en la carpeta «my_geonode/my_geonode/static/css».
El archivo está vacío para que podamos inspeccionar elementos de la página de inicio con las herramientas de desarrollo del navegador y definir reglas CSS allí.
Por ejemplo, si queremos cambiar el fondo del jumbotron, en este archivo podemos agregar
.msgapi .gn-hero .jumbotron { background: red }
Luego, una vez que actualicemos el navegador, deberíamos ver el cambio de la siguiente manera:
El menú superior:
Ahora podemos realizar algunos cambios que se aplicarán a todo el sitio. Podemos agregar un elemento tanto en el lado izquierdo como en el derecho de la barra de menú superior.
Esto se puede hacer creando un get_menu_json.py en la carpeta templatetags para anular el menú predeterminado de GeoNode.
@register.simple_tag(takes_context=True)
def get_base_right_topbar_menu(context):
is_mobile = _is_mobile_device(context)
if is_mobile:
return []
return [
{
"type": "link",
"href": "/",
"label": "Custom 3"
},
{
"type": "link",
"href": "/",
"label": "Custom 4"
},
]
@register.simple_tag(takes_context=True)
def get_base_left_topbar_menu(context):
is_mobile = _is_mobile_device(context)
return [
{
"type": "link",
"href": "/",
"label": "Custom 1"
},
{
"type": "link",
"href": "/",
"label": "Custom 2"
},
]
Al actualizar el navegador, verás una nueva entrada en la barra de navegación que es persistente en todo el sitio.
Modificar funcionalidad
En esta sección, parchearemos la base de recursos de GeoNode y actualizaremos las plantillas para agregar un campo más al esquema de metadatos.
Agregaremos un campo DOI al modelo ResourceBase y modificaremos las Plantillas para mostrar el nuevo campo en la página del Asistente de metadatos.
Nota
Asegúrate de estar dentro del directorio «my_geonode» para ejecutar los siguientes comandos
La personalización de metadatos se puede lograr desde el modelo que se define en el núcleo en «geonode/geonode/base/models.py» de la siguiente manera:
# internal fields
uuid = models.CharField(max_length=36)
owner = models.ForeignKey(
settings.AUTH_USER_MODEL,
blank=True,
null=True,
related_name='owned_resource',
verbose_name=_("Owner"))
contacts = models.ManyToManyField(
settings.AUTH_USER_MODEL,
through='ContactRole')
title = models.CharField(_('title'), max_length=255, help_text=_(
'name by which the cited resource is known'))
alternate = models.CharField(max_length=128, null=True, blank=True)
date = models.DateTimeField(
_('date'),
default=now,
help_text=date_help_text)
date_type = models.CharField(
_('date type'),
max_length=255,
choices=VALID_DATE_TYPES,
default='publication',
help_text=date_type_help_text)
edition = models.CharField(
_('edition'),
max_length=255,
blank=True,
null=True,
help_text=edition_help_text)
abstract = models.TextField(
_('abstract'),
max_length=2000,
blank=True,
help_text=abstract_help_text)
purpose = models.TextField(
_('purpose'),
max_length=500,
null=True,
blank=True,
help_text=purpose_help_text)
maintenance_frequency = models.CharField(
_('maintenance frequency'),
max_length=255,
choices=UPDATE_FREQUENCIES,
blank=True,
null=True,
help_text=maintenance_frequency_help_text)
Para agregar campos directamente a la clase ResourceBase sin modificarla realmente, esto se puede hacer desde el archivo «my_geonode/src/my_geonode/apps.py»
El método «listo» se invoca en el momento de la inicialización y actualmente se puede utilizar para modificar su aplicación de varias maneras.
class AppConfig(BaseAppConfig):
name = "my_geonode"
label = "my_geonode"
def ready(self):
super(AppConfig, self).ready()
run_setup_hooks()
Ahora agregaremos el método «patch_resource_base» a AppConfig y lo ejecutaremos desde el método ready de la siguiente manera:
from django.db import models
from django.utils.translation import ugettext_lazy as _
class AppConfig(BaseAppConfig):
name = "my_geonode"
label = "my_geonode"
def _get_logger(self):
import logging
return logging.getLogger(self.__class__.__module__)
def patch_resource_base(self, cls):
self._get_logger().info("Patching Resource Base")
doi_help_text = _('a DOI will be added by Admin before publication.')
doi = models.TextField(
_('DOI'),
blank=True,
null=True,
help_text=doi_help_text)
cls.add_to_class('doi', doi)
def ready(self):
super(AppConfig, self).ready()
run_setup_hooks()
from geonode.base.models import ResourceBase
self.patch_resource_base(ResourceBase)
Nota
Necesitarás realizar migraciones de la siguiente manera: - Agregar el campo doi a la base de recursos
Una vez que ejecutes python manage.py migrants:
Running migrations:
Applying announcements.0002_auto_20200119_1257... OK
Applying base.0031_resourcebase_doi... OK
Applying people.0027_auto_20200119_1257... OK
Hasta ahora hemos parcheado la base de datos. Sin embargo, aún no es suficiente ya que aún necesitamos mostrar el campo agregado.
Ampliemos las plantillas predeterminadas para que podamos mostrar el campo recién agregado
3- Crea tu propia aplicación django¶
En esta sección, demostraremos cómo crear y configurar el esqueleto de una aplicación personalizada utilizando las funciones de Django. La aplicación agregará una funcionalidad de geocolecciones a nuestro GeoNode.
La aplicación Geocollections permite presentar en una sola página recursos y usuarios agrupados por un Grupo GeoNode. Podemos asignar recursos arbitrarios a una Geocollection, un Grupo y un nombre que también será utilizado para construir una URL dedicada.
Nota
Asegúrate de estar dentro del directorio «my_geonode» para ejecutar los siguientes comandos
Crear la aplicación django
Django nos proporciona un comando muy útil para crear aplicaciones. Ya hemos utilizado startproject para crear nuestro proyecto geonode, ahora podemos utilizar startapp para crear la aplicación.
python manage.py startapp geocollections
Esto creará una carpeta llamada geocollections que contiene modelos y vistas vacíos.
Necesitamos agregar la nueva aplicación a INSTALLED_APPS de nuestro proyecto dentro de «my_geonode/src/my_geonode/settings.py»:
INSTALLED_APPS += (PROJECT_NAME,) to be: INSTALLED_APPS += (PROJECT_NAME, 'geocollections',)
Agregar un modelo personalizado
En esta sección, agregaremos un modelo personalizado y la lógica relacionada de la siguiente manera:
Agregar un nuevo modelo
Agregar URL y vistas
Agregar panel de administración
Añadir la plantilla
vim geocollections/models.py
from django.db import models
from geonode.base.models import ResourceBase
from geonode.groups.models import GroupProfile
class Geocollection(models.Model):
"""
A collection is a set of resources linked to a GeoNode group
"""
group = models.ForeignKey(GroupProfile, related_name='group_collections')
resources = models.ManyToManyField(ResourceBase, related_name='resource_collections')
name = models.CharField(max_length=128, unique=True)
slug = models.SlugField(max_length=128, unique=True)
def __unicode__(self):
return self.name
En este punto, debemos pedirle a Django que cree la tabla de la base de datos. Django, desde la versión 1.8, tiene incorporado un mecanismo de migraciones y debemos usarlo para cambiar el estado de la base de datos.
Nota
Asegúrate de estar dentro del directorio «my_geonode» para ejecutar los siguientes comandos
python manage.py makemigrations
# the above command informs you with the migrations to be executed on the database
python manage.py migrate
A continuación, utilizaremos la vista genérica de Django para mostrar el detalle de las colecciones. Agrega el siguiente código en el archivo views.py:
vim geocollections/views.py
from django.views.generic import DetailView
from .models import Geocollection
class GeocollectionDetail(DetailView):
model = Geocollection
Agregar configuración de URL
Para poder acceder a la vista creada, también necesitamos una asignación de URL. Podemos crear un archivo urls.py que contenga una asignación de URL a nuestra vista genérica:
vim geocollections/urls.py
from django.conf.urls import url
from .views import GeocollectionDetail
urlpatterns = [
url(r'^(?P<slug>[-\w]+)/$',
GeocollectionDetail.as_view(),
name='geocollection-detail'),
]
También necesitamos registrar las URL de la aplicación en las URL del proyecto. Por lo tanto, modifiquemos el archivo urls.py de «my_geonode» y agreguemos lo siguiente:
vim my_geonode/src/my_geonode/urls.py
...
urlpatterns += [
## include your urls here
url(r'^geocollections/', include('geocollections.urls')),
]
...
Habilitar el panel de administración
Necesitamos una interfaz de usuario donde podamos crear geocolecciones. Django lo hace muy fácil, solo necesitamos el archivo admin.py como se muestra a continuación:
vim geocollections/admin.py
from django.contrib import admin
from .models import Geocollection
class GeocollectionAdmin(admin.ModelAdmin):
prepopulated_fields = {"slug": ("name",)}
filter_horizontal = ('resources',)
admin.site.register(Geocollection, GeocollectionAdmin)
Ahora podemos visitar la página de administración y crear una geocolección desde allí de la siguiente manera:
Añadiendo la plantilla
Ahora necesitamos la plantilla donde se representarán los detalles de la geocolección. Vamos a crear un directorio de geocolecciones dentro del directorio «my_geonode/templates» con un archivo llamado geocollection_detail.html:
mkdir -p my_geonode/templates/geocollections/
vim my_geonode/templates/geocollections/geocollection_detail.html
{% extends "geonode_base.html" %}
{% block body %}
<h2>Geocollection {{ object.name }}</h2>
<p>Group: {{ object.group.title }}</p>
<p>Resources:</p>
<ul>
{% for resource in object.resources.all %}
<li>{{ resource.title }}</li>
{% endfor %}
</ul>
{% endblock %}
Para comprobar los resultados, crea un grupo en la interfaz de usuario de Geonode y carga una o más capas/documentos
inicie sesión en el panel de administración -> geocolecciones y crea una geocoleccion
Visita http://localhost:8000/geocollections/<the-name-of-the-created-geocollection> y ve los resultados.
Ahora que sabes cómo personalizar una plantilla html, puedes ajustar la página como prefieras.
Permisos y API
En esta sección, agregaremos lógica más avanzada, como permisos y API. Los permisos en GeoNode se administran con django-guardian, una biblioteca que permite establecer permisos a nivel de objeto (django tiene autorización a nivel de tabla).
Las API se implementan a través de django-tastypie.
Los temas que se tratarán incluyen:
Permisos sobre quién puede ver la geocolección
Cómo agregar plantillas y js para incrustar una interfaz de usuario de permisos en nuestra página de detalles de georrecolección
API para servir un punto final de búsqueda serializado en formato json
Lógica de permisos (objetos de permisos)
Necesitamos agregar el objeto de permisos a la base de datos. Podemos hacerlo añadiendo la siguiente clase meta a nuestro modelo Geocollection, y guardian se encargará de crear los objetos por nosotros.
vim geocollections/models.py
class Meta:
permissions = (
('view_geocollection', 'Can view geocollection'),
)
Luego ejecuta «python manage.py makemigrations» y «python manage.py migrants» para instalarlos.
Lógica de permisos (set_default)
Agreguemos un método que se utilizará para establecer los permisos predeterminados en las colecciones geográficas. Podemos agregar esta lógica al modelo de colección geográfica, pero también podría ser una combinación genérica similar a cómo se implementa en GeoNode.
vim geocollections/models.py
from django.contrib.auth.models import Group
from django.contrib.auth import get_user_model
from django.contrib.contenttypes.models import ContentType
from django.conf import settings
from guardian.shortcuts import assign_perm
def set_default_permissions(self):
"""
Set default permissions.
"""
self.remove_object_permissions()
# default permissions for anonymous users
anonymous_group, created = Group.objects.get_or_create(name='anonymous')
if settings.DEFAULT_ANONYMOUS_VIEW_PERMISSION:
assign_perm('view_geocollection', anonymous_group, self)
# default permissions for group members
assign_perm('view_geocollection', self.group, self)
Lógica de permisos (métodos)
Ahora necesitamos un método para agregar permisos genéricos. Queremos poder asignar permisos de visualización a grupos y usuarios individuales. Podemos agregar esto a nuestro modelo de georreferenciación.
vim geocollections/models.py
def set_permissions(self, perm_spec):
anonymous_group = Group.objects.get(name='anonymous')
self.remove_object_permissions()
if 'users' in perm_spec and "AnonymousUser" in perm_spec['users']:
assign_perm('view_geocollection', anonymous_group, self)
if 'users' in perm_spec:
for user, perms in perm_spec['users'].items():
user = get_user_model().objects.get(username=user)
assign_perm('view_geocollection', user, self)
if 'groups' in perm_spec:
for group, perms in perm_spec['groups'].items():
group = Group.objects.get(name=group)
assign_perm('view_geocollection', group, self)
def remove_object_permissions(self):
from guardian.models import UserObjectPermission, GroupObjectPermission
UserObjectPermission.objects.filter(content_type=ContentType.objects.get_for_model(self),
object_pk=self.id).delete()
GroupObjectPermission.objects.filter(content_type=ContentType.objects.get_for_model(self),
object_pk=self.id).delete()
Lógica de permisos (views.py)
Ahora podemos agregar una vista para recibir y configurar nuestros permisos, en views.py:
vim geocollections/views.py
import json
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from django.contrib.auth import get_user_model
User = get_user_model()
def geocollection_permissions(request, collection_id):
collection = Geocollection.objects.get(id=collection_id)
user = User.objects.get(id=request.user.id)
if user.has_perm('view_geocollection', collection):
return HttpResponse(
'You have the permission to view. please customize a template for this view'',
content_type='text/plain')
if request.method == 'POST':
success = True
message = "Permissions successfully updated!"
try:
permission_spec = json.loads(request.body)
collection.set_permissions(permission_spec)
return HttpResponse(
json.dumps({'success': success, 'message': message}),
status=200,
content_type='text/plain'
)
except:
success = False
message = "Error updating permissions :("
return HttpResponse(
json.dumps({'success': success, 'message': message}),
status=500,
content_type='text/plain'
)
Lógica de permisos (URL)
Por último, necesitamos una URL para mapear nuestro cliente a nuestra vista, en urls.py
vim geocollections/urls.py
from django.conf.urls import url
from .views import GeocollectionDetail, geocollection_permissions
urlpatterns = [
url(r'^(?P<slug>[-\w]+)/$',
GeocollectionDetail.as_view(),
name='geocollection-detail'),
url(r'^permissions/(?P<collection_id>\d+)$',
geocollection_permissions,
name='geocollection_permissions'),
]
Esta URL será llamada con el id de la geocolección, el id se pasará a la vista para obtener los permisos.
Advertencia
Una nota sobre la parte del cliente, la lógica del lado del servidor es solo una parte necesaria para implementar permisos.
Una lista de verificación de lo que es necesario:
Un fragmento de plantilla que se puede incrustar en geocollection_detail.html, puedes copiar y simplificar: _permissions_form.html y _permissions.html (en geonode/templates)
Un archivo javascript que recopilará configuraciones de permisos y las enviará al servidor, puedes copiar y simplificar: _permissions_form_js.html (en geonode/templates)
API
El sistema API de GeoNode permite conectar fácilmente nuevas API. Esta sección muestra los pasos necesarios:
Primero necesitamos crear un archivo api.py en nuestra aplicación de georecolección.
vim geocollections/api.py
import json
from tastypie.resources import ModelResource
from tastypie import fields
from tastypie.constants import ALL_WITH_RELATIONS, ALL
from geonode.api.api import ProfileResource, GroupResource
from geonode.api.resourcebase_api import ResourceBaseResource
from .models import Geocollection
class GeocollectionResource(ModelResource):
users = fields.ToManyField(ProfileResource, attribute=lambda bundle: bundle.obj.group.group.user_set.all(), full=True)
group = fields.ToOneField(GroupResource, 'group', full=True)
resources = fields.ToManyField(ResourceBaseResource, 'resources', full=True)
class Meta:
queryset = Geocollection.objects.all().order_by('-group')
ordering = ['group']
allowed_methods = ['get']
resource_name = 'geocollections'
filtering = {
'group': ALL_WITH_RELATIONS,
'id': ALL
}
Autorización API
Queremos que la API respete nuestros permisos personalizados, podemos lograrlo fácilmente agregando lo siguiente al comienzo de api.py:
vim geocollections/api.py
from tastypie.authorization import DjangoAuthorization
from guardian.shortcuts import get_objects_for_user
class GeocollectionAuth(DjangoAuthorization):
def read_list(self, object_list, bundle):
permitted_ids = get_objects_for_user(
bundle.request.user,
'geocollections.view_geocollection').values('id')
return object_list.filter(id__in=permitted_ids)
def read_detail(self, object_list, bundle):
return bundle.request.user.has_perm(
'view_geocollection',
bundle.obj)
Y esto para la clase Meta GeocollectionResource:
authorization = GeocollectionAuth()
Agrega una URL para nuestra API
Para publicar nuestra API necesitamos una URL y queremos que esa URL aparezca bajo el dominio /api de GeoNode.
La URL final de nuestra API debe ser /api/geocollections.
Podemos inyectar la URL en la API de GeoNode agregando las siguientes líneas al archivo «my_geonode/urls.py»:
vim my_geonode/urls.py
from geonode.api.urls import api
from geocollections.api import GeocollectionResource
api.register(GeocollectionResource())
Y añade lo siguiente en urlpatterns:
url(r'', include(api.urls)),
El resultado final será:
from django.conf.urls import url, include
from django.views.generic import TemplateView
from geonode.urls import urlpatterns
from geonode.api.urls import api
from geocollections.api import GeocollectionResource
api.register(GeocollectionResource())
urlpatterns += [
## include your urls here
url(r'', include(api.urls)),
url(r'^geocollections/', include('geocollections.urls')),
]
Probemos los permisos en la API
Podemos probar los permisos en la API estableciendo manualmente un permiso desde la línea de comando y verificar que la API lo respete.
Al ejecutar python manage.py shell desde dentro de nuestra carpeta «my_geonode», se abre un shell de GeoNode.
Una especificación permanente podría verse así:
perms = {
'users': {
'AnonymousUser': ['view_geocollection'],
'alessio': ['view_geocollection']}
}
y podemos asignar los permisos con:
from geocollections.models import Geocollection
Geocollection.objects.first().set_permissions(perms)
Nuestro http://localhost:8000/api/geocollections ahora debería incluir la geocolección.
Si eliminas la línea “AnonymousUser” de los permisos y vuelves a asignar los permisos, desaparecerá.
perms = {
'users': {
'alessio': ['view_geocollection']
}
Implementa tu GeoNode
Hasta ahora hemos demostrado cómo modificar, ampliar y dar estilo a nuestro GeoNode en modo de desarrollo, pero ahora es momento de pasar a producción. En esta sección, aclararemos cómo:
sube tu trabajo a GitHub
configura tu servidor
configura tu GeoNode para producción
Haz un push a GitHub. Siempre es una buena práctica mantener tu código en un repositorio remoto. GitHub es una de las opciones disponibles y, de hecho, es la más utilizada.
Se supone que ya tienes una cuenta de GitHub y que tienes git instalado y configurado con tu nombre y correo electrónico.
Solo enviaremos la carpeta my_geonode a GitHub y, como sabíamos antes, GeoNode para nosotros es una dependencia y simplemente lo reinstalaremos tal como está en el servidor.
Pasos para enviar tu código a GitHub:
Crea un repositorio vacío en GitHub y copia su dirección
En my_geonode, ejecute git init para inicializar un repositorio vacío
Agrega tu repositorio remoto, usa el siguiente comando:
git remote add yourname yourremoteaddressen tu terminalEditar .gitignore agregando todos los archivos
*.pycgit add *para agregar todo el contenido de my_geonodegit commit -m 'initial import'para realizar la confirmación inicialgit push yourname masterpara enviar el código al repositorio de GitHub
Configurar el servidor
Existen varias opciones para implementar proyectos GeoNode en servidores. En esta sección, explicamos cómo implementarlo en un servidor Ubuntu 18.04 mediante una instalación en todo el sistema.
Nota
Para una instalación rápida, sigue la documentación de INSTALACIÓN en http://docs.geonode.org/en/master/install/core/index.html
Configurar nuestro my_geonode
Ahora necesitamos instalar el proyecto desarrollado “my_geonode” siguiendo estos pasos:
git clone desde su repositorio (en la carpeta de su preferencia)
sudo pip install -e my_geonodeedite la configuración donde sea necesario
edite
/etc/apache2/sites-enabled/geonode.confreemplazando la ruta wsgi al archivomy_geonode/my_geonode/wsgi.pyagrega los permisos de Apache a la carpeta «my_geonode» con un directorio como el siguiente
<Directory "/path/to/my_geonode/">
Order allow,deny
Require all granted
</Directory>
Pruebe tu servidor.