Mudanças entre as edições de "Manual de instalação"

Edição atual tal como às 13h49min de 9 de janeiro de 2017

Guia de instalação do CKAN

Descrição:

CKAN é uma ferramenta para fazer sites de dados abertos. (Semelhante a um sistema de gerenciamento de conteúdo como o WordPress - mas para dados, em vez de páginas e posts.) Ele ajuda você a gerenciar e publicar coleções de dados. Ele é usado por governos nacionais e locais, instituições de pesquisa e outras organizações que recolhem um monte de dados.

Uma vez que os dados são publicados, os usuários podem usar seus recursos de pesquisa facetada para procurar e encontrar os dados de que necessitam, e visualizá-lo usando mapas, gráficos e tabelas - se eles são desenvolvedores, jornalistas, pesquisadores, ONGs, cidadãos, ou mesmo a sua própria equipe.

CKAN Site: http://ckan.org/ CKAN Wiki: http://docs.ckan.org/en/latest/

Este guia é baseado nas informações encontradas em: http://docs.ckan.org/en/latest/maintaining/installing/install-from-source.html

Este guia baseia-se na instalação em uma máquina Debian GNU/Linux 8 (jessie) com processador Intel Xeon 2.53GHz e 4GB de memória RAM.

Pacotes Necessários:

Instale os pacotes necessários:

$ sudo apt-get install python-dev postgresql libpq-dev python-pip python-virtualenv git-core solr-jetty openjdk-7-jdk

Instale o CKAN no Ambiente virtual Python:

É recomendável que você instale o CKAN no seu diretório base ('home') e depois você pode fazer links simbólicos para as pastas de instalação:

$ mkdir -p ~/ckan/lib
$ sudo ln -s ~/ckan/lib /usr/lib/ckan
$ mkdir -p ~/ckan/etc
$ sudo ln -s ~/ckan/etc /etc/ckan

Crie o ambiente virtual com o 'virtualenv' para instalar o CKAN.

$ sudo mkdir -p /usr/lib/ckan/default
$ sudo chown `whoami` /usr/lib/ckan/default
$ virtualenv --no-site-packages /usr/lib/ckan/default
$ . /usr/lib/ckan/default/bin/activate

Obs.: Ao executar o comando final, você entrará no ambiente de virtualização Python. Ele é caracterizado por aparecer “(default) $ _” na frente do prompt de comando. Toda a instalação do CKAN é feita dentro deste ambiente. Caso você saia deste ambiente por algum motivo, ex.: fechar a janela do terminal, entre novamente com o seguinte comando: “. /usr/lib/ckan/default/bin/activate”.

Agora instale o CKAN a partir do código fonte localizado no GitHub:

(default) $ _ pip install -e 'git+https://github.com/ckan/ckan.git@ckan-2.5.2#egg=ckan'

Agora instale os modulos Python que o CKAN necessita para no ambiente 'virtualenv':

(default) $ _ pip install -r /usr/lib/ckan/default/src/ckan/requirements.txt

Agora desative e reative o ambiente 'virtualenv' para que as configurações instaladas fiquem válidas:

(default) $ _ deactivate
$ . /usr/lib/ckan/default/bin/activate

Configure o Banco de dados PostgreSQL:

Rode o seguinte comando e certifique-se que todas as bases instaladas estão com a codificação UTF-8:

(default) $ _ sudo -u postgres psql -l

Obs.: Se as bases existentes não estiverem em UTF-8, faça com que todas fiquem e só então prossiga com a instalação.

Crie um novo usuário do banco de dados com o nome 'ckan_default' e coloque a senha dele (<password>):

(default) $ _ sudo -u postgres createuser -S -D -R -P ckan_default

Agora crie uma nova base de dados no PostgreSQL chamada 'ckan_default' e conceda todos os privilégios para o usuário 'ckan_default':

(default) $ _ sudo -u postgres createdb -O ckan_default ckan_default -E utf-8

Crie o arquivo de configuração do CKAN:

Crie o diretório padrão do arquivo e dê permissão para seu usuário escrever nele:

(default) $ _ sudo mkdir -p /etc/ckan/default
(default) $ _ sudo chown -R `whoami` /etc/ckan/
(default) $ _ sudo chown -R `whoami` ~/ckan/etc

Crie o arquivo de configuração do CKAN:

(default) $ _ paster make-config ckan /etc/ckan/default/development.ini

Agora edite o arquivo criado para configurar a conexão com o banco de dados PostgreSQL.

(default) $ _ nano /etc/ckan/default/development.ini

Na linha:

sqlalchemy.url = postgresql://ckan_default:pass@<remotehost>/ckan_default?sslmode=disable

Obs.: Modifique a palavra 'pass' para a senha <password> criado na Seção 4.

Na linha:

ckan.site_url = http://localhost/

Configure o Jetty-Solr:

O CKAN usa Solr como a sua plataforma de busca, e usa um arquivo xml personalizado para o Solr que leva em consideração as necessidades de pesquisa para o CKAN. Com o CKAN instalado, é preciso instalar e configurar o Solr.

Edite o arquivo '/etc/default/jetty8' e modifique as seguintes variáveis:

NO_START=0            # (linha 4)
JETTY_HOST=127.0.0.1  # (linha 16, Coloque 0.0.0.0 para aceitar conexões de todos os hosts)
JETTY_PORT=8983       # (linha 20)

Agora inicie o Jetty:

(default) $ _ sudo service jetty8 restart

Substitua o 'schema.xml' do nativo do Solr para o 'schema.xml' do CKAN:

(default) $ _ sudo mv /etc/solr/conf/schema.xml /etc/solr/conf/schema.xml.bak
(default) $ _ sudo ln -s /usr/lib/ckan/default/src/ckan/ckan/config/solr/schema.xml /etc/solr/conf/schema.xml

Agora reinicie o Solr:

(default) $ _ sudo service jetty8 restart

Agora configure a url no Solr no seu arquivo de configuração do CKAN:

(default) $ _ nano /etc/ckan/default/development.ini

Na linha:

solr_url=http://127.0.0.1:8983/solr

Crie as tabelas no banco de dados PostgreSQL:

Crie as tabelas no banco de dados seguindo os seguintes comandos:

(default) $ _ cd /usr/lib/ckan/default/src/ckan
(default) $ _ paster db init -c /etc/ckan/default/development.ini

Você deverá ver: “Initialising DB: SUCCESS”

Configurar o Arquivo who.ini:

Crie um link simbólico do arquivo de inicialização do CKAN na pasta padrão:

(default) $ _ ln -s /usr/lib/ckan/default/src/ckan/who.ini /etc/ckan/default/who.ini

A partir de então, o CKAN já pode ser inicializado. Para iniciar execute:

(default) $ _ cd /usr/lib/ckan/default/src/ckan
(default) $ _ paster serve /etc/ckan/default/development.ini

Abra o seu navegador e entre em: 'http://127.0.0.1:5000/'; Você será capaz de ver o CKAN em funcionamento já.

Configurar o Apache e o Nginx no CKAN:

Crie o arquivo de configuração, para o ambiente de produção que será executado no Apache e no Nginx:

$ cp /etc/ckan/default/development.ini /etc/ckan/default/production.ini

Obs.: Note que o arquivo é uma cópia do arquivo do ambiente de testes (Seção 9) que é executado na porta 5000. O ambiente de produção será executado nas portas 80 e 8080 no Ngynx e no Apache, respectivamente.

Agora, faça a instalação dos pacotes necessários:

$ sudo apt-get install apache2 libapache2-mod-wsgi libapache2-mod-rpaf nginx

Crie o script WSGI que será executado no Apache:

$ nano /etc/ckan/default/apache.wsgi

Adicione o seguinte conteúdo:

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

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

Obs.: Certifique-se que a pasta '/usr/lib/ckan/default/bin/' contém o arquivo 'activate_this.py'.

Vá na pasta do seu Apache e crie um novo site:

$ sudo nano /etc/apache2/sites-available/ckan.conf

Adicione o seguinte conteúdo:

<VirtualHost *:8080>
    WSGIScriptAlias / /etc/ckan/default/apache.wsgi

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

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

    WSGIProcessGroup ckan_default

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

    <IfModule mod_rpaf.c>
        RPAFenable On
        RPAFsethostname On
        RPAFproxy_ips 127.0.0.1
    </IfModule>

    <Directory />
        Require all granted
    </Directory>

</VirtualHost>

Configure o Apache para ouvir na porta 8080. No arquivo:

$ sudo nano /etc/apache2/ports.conf

Modifique a linha:

#Listen 80 para:
Listen 8080

Agora configure seu site no Nginx:

$ sudo nano /etc/nginx/sites-available/ckan

Adicione as linhas:

proxy_cache_path /tmp/nginx_cache levels=1:2 keys_zone=cache:30m max_size=250m;
proxy_temp_path /tmp/nginx_proxy 1 2;

server {
    client_max_body_size 100M;
    location / {
        proxy_pass http://127.0.0.1:8080/;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Host $host;
        proxy_cache cache;
        proxy_cache_bypass $cookie_auth_tkt;
        proxy_no_cache $cookie_auth_tkt;
        proxy_cache_valid 30m;
        proxy_cache_key $host$scheme$proxy_host$request_uri;
        # In emergency comment out line to force caching
        # proxy_ignore_headers X-Accel-Expires Expires Cache-Control;
    }

}

Habilite seu site no Apache e no Nginx seguindo os seguintes comandos:

$ sudo a2ensite ckan.conf
$ sudo a2dissite 000-default.conf
$ sudo rm -vi /etc/nginx/sites-enabled/default
$ sudo ln -s /etc/nginx/sites-available/ckan /etc/nginx/sites-enabled/ckan_default
$ sudo service apache2 restart
$ sudo service nginx restart

Obs.: Note que a sequencia de comandos desabilitou o site 'default' no Apache e no Nginx. Verifique se os arquivos dentro da '/etc/ckan/default/' estão com a permissão '-rw-r--r--'. Verifique também se o todos os diretórios até o '/' tá com a permissão 'drwxr-xr-x'.

Configure o DataStore:

A extensão CKAN DataStore fornece um banco de dados adhoc para o armazenamento de dados estruturados a partir de recursos do CKAN. Os dados podem ser puxados para fora de arquivos de recursos e armazenados no armazenamento de dados.

Abra o arquivo de configuração do CKAN e adicione a opção 'datastore' em 'ckan.plugins':

(default) $ _ nano /etc/ckan/default/development.ini

Na linha:

ckan.plugins = stats text_view image_view recline_view datastore

Agora crie o usuário 'datastore_default' no banco de dados PostgreSQL e configure sua senha:

(default) $ _ sudo -u postgres createuser -S -D -R -P -l datastore_default

Cria a base de dados 'datastore_default' para o usuário 'ckan_default' criado na Seção 4:

(default) $ _ sudo -u postgres createdb -O ckan_default datastore_default -E utf-8

Abra o arquivo de configuração do CKAN e modifique as seguintes opções:

(default) $ _ nano /etc/ckan/default/development.ini

Na linhas:

ckan.datastore.write_url = postgresql://ckan_default:pass@localhost/datastore_default
ckan.datastore.read_url = postgresql://datastore_default:pass@localhost/datastore_default

Obs.: Modifique a palavra 'pass' para as respectivas senhas criadas.

Uma vez que as bases de dados e os usuários foram criados, as permissões devem ser configuradas no banco de dados PostgreSQL. Para isso, entre no ambiente do PostgreSQL:

(default) $ _ sudo -u postgres psql

Agora execute os seguintes comandos em sequencia dentro do ambiente “postgres=#”:

\connect datastore_default
REVOKE CREATE ON SCHEMA public FROM PUBLIC;
REVOKE USAGE ON SCHEMA public FROM PUBLIC;
GRANT CREATE ON SCHEMA public TO "ckan_default";
GRANT USAGE ON SCHEMA public TO "ckan_default";
GRANT CREATE ON SCHEMA public TO "ckan_default";
GRANT USAGE ON SCHEMA public TO "ckan_default";
REVOKE CONNECT ON DATABASE "ckan_default" FROM "datastore_default";
GRANT CONNECT ON DATABASE "datastore_default" TO "datastore_default";
GRANT USAGE ON SCHEMA public TO "datastore_default";
GRANT SELECT ON ALL TABLES IN SCHEMA public TO "datastore_default";
ALTER DEFAULT PRIVILEGES FOR USER "ckan_default" IN SCHEMA public GRANT SELECT ON TABLES TO "datastore_default";
\q

Obs.: Caso você tenha modificado o nome dos usuários, ajuste os comandos.

Configure o FileStore:

Agora é necessário instalar o FileStore, para que arquivos seja carregados no CKAN e seus dados serem inseridos no banco de dados. Cria a pasta onde o CKAN vai armazenar os arquivos:

(default) $ _ sudo mkdir -p /var/lib/ckan/default

Abra o arquivo de configuração do CKAN e adicione a seguinte opção:

(default) $ _ nano /etc/ckan/default/development.ini

Na linha:

ckan.storage_path = /var/lib/ckan/default

Dê as permissões para a pasta e coloque como dono o usuário 'www-data':

(default) $ _ sudo chown www-data /var/lib/ckan/default
(default) $ _ sudo chmod u+rwx /var/lib/ckan/default

Configure o DataPusher:

Esta aplicação é um serviço que adiciona o carregamento automático de arquivos CSV/Excel para CKAN. Instale todos os requisitos para o DataPusher:

$ sudo apt-get install python-dev python-virtualenv build-essential libxslt1-dev libxml2-dev git

Crie o ambiente virtual Python para o datapusher

$ sudo virtualenv /usr/lib/ckan/datapusher

Crie a seguinte pasta e entre nela:

$ sudo mkdir /usr/lib/ckan/datapusher/src
$ cd /usr/lib/ckan/datapusher/src

Clone o repositório para dentro da pasta:

$ sudo git clone -b stable https://github.com/ckan/datapusher.git

Instale o DataPusher:

$ cd datapusher
$ sudo /usr/lib/ckan/datapusher/bin/pip install -r requirements.txt
$ sudo /usr/lib/ckan/datapusher/bin/python setup.py develop
$ sudo chown -R `whoami` /usr/lib/ckan/datapusher/

Copie o arquivo para criar o site/serviço no Apache:

$ sudo cp deployment/datapusher.conf /etc/apache2/sites-available/datapusher.conf

Copie o arquivo wsgi para a pasta 'default' do CKAN:

$ sudo cp deployment/datapusher.wsgi /etc/ckan/default/

Copie as configurações do datapusher:

$ sudo cp deployment/datapusher_settings.py /etc/ckan/default/

Modifique as permissões:

$ sudo chown -R `whoami` /etc/ckan/default/

Configure o Apache para ouvir na porta 8800. No arquivo:

$ sudo nano /etc/apache2/ports.conf

Adicione a linha:

Listen 8800

Agora configure:

$ nano /etc/ckan/default/datapusher.wsgi

Modifique a linha e deixe da seguinte forma:

os.environ['JOB_CONFIG'] = '/etc/ckan/default/datapusher_settings.py'

No arquivo:

$ sudo nano /etc/apache2/sites-available/datapusher.conf

Modifique a linha e deixe da seguinte forma:

WSGIScriptAlias / /etc/ckan/default/datapusher.wsgi

Agora habilite o site no apache:

$ sudo a2ensite datapusher.conf

Reinicie o Apache e o Nginx:

$ sudo service apache2 restart
$ sudo service nginx restart

Você será capaz de ver o CKAN sendo executado em 'http://127.0.0.1:8080/' (Apache) e 'http://127.0.0.1/' (Nginx).