2.2. Detailed installation guide

CAVEAT LECTOR

Invenio v3.0 alpha is a bleeding-edge developer preview version.

2.2.1. Introduction

In this installation guide, we’ll create an Invenio digital library instance using a multi-machine setup where separate services (such as the database server and the web server) run on separate dedicated machines. Such a multi-machine setup emulates to what one would typically use in production. (However, it is very well possible to follow this guide and install all the services onto the same “localhost”, if one wants to.)

We’ll use six dedicated machines running the following services:

node IP runs
web 192.168.50.10 Invenio web application
postgresql 192.168.50.11 PostgreSQL database server
redis 192.168.50.12 Redis caching service
elasticsearch 192.168.50.13 Elasticsearch information retrieval service
rabbitmq 192.168.50.14 RabbitMQ messaging service
worker 192.168.50.15 Celery worker node

The instructions below are tested on Ubuntu 14.04 LTS (Trusty Tahr) and CentOS 7 operating systems. For other operating systems such as Mac OS X, you may want to check out the “kickstart” set of scripts coming with the Invenio source code that perform the below-quoted installation steps in an unattended automated way.

2.2.2. Environment variables

Let’s define some useful environment variables that will describe our Invenio instance setup:

INVENIO_WEB_HOST
The IP address of the Web server node.
INVENIO_WEB_INSTANCE
The name of your Invenio instance that will be created. Usually equal to the name of the Python virtual environment.
INVENIO_WEB_VENV
The name of the Python virtual environment where Invenio will be installed. Usually equal to the name of the Invenio instance.
INVENIO_USER_EMAIL
The email address of a user account that will be created on the Invenio instance.
INVENIO_USER_PASS
The password of this Invenio user.
INVENIO_POSTGRESQL_HOST
The IP address of the PostgreSQL database server.
INVENIO_POSTGRESQL_DBNAME
The database name that will hold persistent data of our Invenio instance.
INVENIO_POSTGRESQL_DBUSER
The database user name used to connect to the database server.
INVENIO_POSTGRESQL_DBPASS
The password of this database user.
INVENIO_REDIS_HOST
The IP address af the Redis server.
INVENIO_ELASTICSEARCH_HOST
The IP address of the Elasticsearch information retrieval server.
INVENIO_RABBITMQ_HOST
The IP address of the RabbitMQ messaging server.
INVENIO_WORKER_HOST
The IP address of the Celery worker node.

In our example setup, we shall use:


export INVENIO_WEB_HOST=192.168.50.10
export INVENIO_WEB_INSTANCE=invenio
export INVENIO_WEB_VENV=invenio
export INVENIO_USER_EMAIL=info@inveniosoftware.org
export INVENIO_USER_PASS=uspass123
export INVENIO_POSTGRESQL_HOST=192.168.50.11
export INVENIO_POSTGRESQL_DBNAME=invenio
export INVENIO_POSTGRESQL_DBUSER=invenio
export INVENIO_POSTGRESQL_DBPASS=dbpass123
export INVENIO_REDIS_HOST=192.168.50.12
export INVENIO_ELASTICSEARCH_HOST=192.168.50.13
export INVENIO_RABBITMQ_HOST=192.168.50.14
export INVENIO_WORKER_HOST=192.168.50.15

Let us save this configuration in a file called .inveniorc for future use.

2.2.3. Web

The web application node (192.168.50.10) is where the main Invenio application will be running. We need to provision it with some system dependencies in order to be able to install various underlying Python and JavaScript libraries.

The web application node can be set up in an automated unattended way by running the following script:

source .inveniorc
./scripts/provision-web.sh

Let’s see in detail what the web provisioning script does.

First, let’s see if using sudo will be required:


# runs as root or needs sudo?
if [[ "$EUID" -ne 0 ]]; then
    sudo='sudo'
else
    sudo=''
fi

Second, some useful system tools are installed:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    # update list of available packages:
    $sudo apt-get -y update

    # install useful system tools:
    $sudo apt-get -y install \
         curl \
         git \
         rlwrap \
         screen \
         vim
    
  • on CentOS 7:

    # add EPEL external repository:
    $sudo yum install -y epel-release

    # install useful system tools:
    $sudo yum install -y \
         curl \
         git \
         rlwrap \
         screen \
         vim
    

Third, an external Node.js package repository is enabled. We’ll be needing to install and run Npm on the web node later. The Node.js repository is enabled as follows:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    if [[ ! -f /etc/apt/sources.list.d/nodesource.list ]]; then
        curl -sL https://deb.nodesource.com/setup_4.x | $sudo bash -
    fi
    
  • on CentOS 7:

    if [[ ! -f /etc/yum.repos.d/nodesource-el.repo ]]; then
        curl -sL https://rpm.nodesource.com/setup_4.x | $sudo bash -
    fi
    

Fourth, all the common prerequisite software libraries and packages that Invenio needs are installed:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    $sudo apt-get -y install \
         libffi-dev \
         libfreetype6-dev \
         libjpeg-dev \
         libmsgpack-dev \
         libssl-dev \
         libtiff-dev \
         libxml2-dev \
         libxslt-dev \
         nodejs \
         python-dev \
         python-pip
    
  • on CentOS7:

    # install development tools:
    $sudo yum update -y
    $sudo yum groupinstall -y "Development Tools"
    $sudo yum install -y \
         libffi-devel \
         libxml2-devel \
         libxslt-devel \
         openssl-devel \
         policycoreutils-python \
         python-devel \
         python-pip
    $sudo yum install -y --disablerepo=epel \
         nodejs
    

We want to use PostgreSQL database in this installation example, so we need to install corresponding libraries too:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    $sudo apt-get -y install \
         libpq-dev
    
  • on CentOS7:

    $sudo yum install -y \
         postgresql-devel
    

Fifth, now that Node.js is installed, we can proceed with installing Npm and associated CSS/JS filter tools. Let’s do it globally:

  • on either of the operating systems:

    # $sudo su -c "npm install -g npm"
    $sudo su -c "npm install -g node-sass@3.8.0 clean-css@3.4.12 requirejs uglify-js"
    

Sixth, we’ll install Python virtual environment wrapper tools and activate them in the current user shell process:

  • on either of the operating systems:

    $sudo pip install -U setuptools pip
    $sudo pip install -U virtualenvwrapper
    if ! grep -q virtualenvwrapper ~/.bashrc; then
        mkdir -p "$HOME/.virtualenvs"
        echo "export WORKON_HOME=$HOME/.virtualenvs" >> "$HOME/.bashrc"
        echo "source $(which virtualenvwrapper.sh)" >> "$HOME/.bashrc"
    fi
    export WORKON_HOME=$HOME/.virtualenvs
    # shellcheck source=/dev/null
    source "$(which virtualenvwrapper.sh)"
    

Seventh, we install Nginx web server and configure appropriate virtual host:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    # install Nginx web server:
    $sudo apt-get install -y nginx

    # configure Nginx web server:
    $sudo cp -f "$scriptpathname/../nginx/invenio.conf" /etc/nginx/sites-available/
    $sudo sed -i "s,/home/invenio/,/home/$(whoami)/,g" /etc/nginx/sites-available/invenio.conf
    $sudo rm /etc/nginx/sites-enabled/default
    $sudo ln -s /etc/nginx/sites-available/invenio.conf /etc/nginx/sites-enabled/
    $sudo /usr/sbin/service nginx restart
    
  • on CentOS7:

    # install Nginx web server:
    $sudo yum install -y nginx

    # configure Nginx web server:
    $sudo cp "$scriptpathname/../nginx/invenio.conf" /etc/nginx/conf.d/
    $sudo sed -i "s,/home/invenio/,/home/$(whoami)/,g" /etc/nginx/conf.d/invenio.conf

    # add SELinux permissions if necessary:
    if $sudo getenforce | grep -q 'Enforcing'; then
        if ! $sudo semanage port -l | tail -n +1 | grep -q '8888'; then
            $sudo semanage port -a -t http_port_t -p tcp 8888
        fi
        if ! $sudo semanage port -l | grep ^http_port_t | grep -q 5000; then
            $sudo semanage port -m -t http_port_t -p tcp 5000
        fi
        if ! $sudo getsebool -a | grep httpd | grep httpd_enable_homedirs | grep -q on; then
            $sudo setsebool -P httpd_enable_homedirs 1
            mkdir -p "/home/$(whoami)/.virtualenvs/${INVENIO_WEB_VENV}/var/instance/static"
            $sudo chcon -R -t httpd_sys_content_t "/home/$(whoami)/.virtualenvs/${INVENIO_WEB_VENV}/var/instance/static"
        fi
    fi

    $sudo sed -i 's,80,8888,g' /etc/nginx/nginx.conf
    $sudo chmod go+rx "/home/$(whoami)/"
    $sudo /sbin/service nginx restart

    # open firewall ports:
    if firewall-cmd --state | grep -q running; then
        $sudo firewall-cmd --permanent --zone=public --add-service=http
        $sudo firewall-cmd --permanent --zone=public --add-service=https
        $sudo firewall-cmd --reload
    fi
    

Finally, let’s clean after ourselves:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    $sudo apt-get -y autoremove && $sudo apt-get -y clean
    
  • on CentOS7:

    $sudo yum clean -y all
    

2.2.4. Database

The database server (192.168.50.11) will hold persistent data of our Invenio installation, such as bibliographic records or user accounts. Invenio supports MySQL, PostgreSQL, and SQLite databases. In this tutorial, we shall use PostgreSQL that is the recommended database platform for Invenio.

The database server node can be set up in an automated unattended way by running the following script:

source .inveniorc
./scripts/provision-postgresql.sh

Let’s see in detail what the database provisioning script does.

First, we install and configure the database software:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    # update list of available packages:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y update

    # install PostgreSQL:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y install \
         postgresql

    # allow network connections:
    if ! grep -q "listen_addresses.*${INVENIO_POSTGRESQL_HOST}" \
         /etc/postgresql/9.3/main/postgresql.conf; then
        echo "listen_addresses = '${INVENIO_POSTGRESQL_HOST}'" | \
            sudo tee -a /etc/postgresql/9.3/main/postgresql.conf
    fi

    # grant access rights:
    if ! sudo grep -q "host.*${INVENIO_POSTGRESQL_DBNAME}.*${INVENIO_POSTGRESQL_DBUSER}" \
         /etc/postgresql/9.3/main/pg_hba.conf; then
        echo "host ${INVENIO_POSTGRESQL_DBNAME} ${INVENIO_POSTGRESQL_DBUSER} ${INVENIO_WEB_HOST}/32 md5" | \
            sudo tee -a /etc/postgresql/9.3/main/pg_hba.conf
    fi

    # grant database creation rights via SQLAlchemy-Utils:
    if ! sudo grep -q "host.*template1.*${INVENIO_POSTGRESQL_DBUSER}" \
         /etc/postgresql/9.3/main/pg_hba.conf; then
        echo "host template1 ${INVENIO_POSTGRESQL_DBUSER} ${INVENIO_WEB_HOST}/32 md5" | \
            sudo tee -a /etc/postgresql/9.3/main/pg_hba.conf
    fi

    # restart PostgreSQL server:
    sudo /etc/init.d/postgresql restart
    
  • on CentOS 7:

    # add EPEL external repository:
    sudo yum install -y epel-release

    # install PostgreSQL:
    sudo yum update -y
    sudo yum install -y \
         postgresql-server

    # initialise PostgreSQL database:
    sudo -i -u postgres pg_ctl initdb

    # allow network connections:
    if ! sudo grep -q "listen_addresses.*${INVENIO_POSTGRESQL_HOST}" \
         /var/lib/pgsql/data/postgresql.conf; then
        echo "listen_addresses = '${INVENIO_POSTGRESQL_HOST}'" | \
            sudo tee -a /var/lib/pgsql/data/postgresql.conf
    fi

    # grant access rights:
    if ! sudo grep -q "host.*${INVENIO_POSTGRESQL_DBNAME}.*${INVENIO_POSTGRESQL_DBUSER}" \
         /var/lib/pgsql/data/pg_hba.conf; then
        echo "host ${INVENIO_POSTGRESQL_DBNAME} ${INVENIO_POSTGRESQL_DBUSER} ${INVENIO_WEB_HOST}/32 md5" | \
            sudo tee -a /var/lib/pgsql/data/pg_hba.conf
    fi

    # grant database creation rights via SQLAlchemy-Utils:
    if ! sudo grep -q "host.*template1.*${INVENIO_POSTGRESQL_DBUSER}" \
         /var/lib/pgsql/data/pg_hba.conf; then
        echo "host template1 ${INVENIO_POSTGRESQL_DBUSER} ${INVENIO_WEB_HOST}/32 md5" | \
            sudo tee -a /var/lib/pgsql/data/pg_hba.conf
    fi

    # open firewall ports:
    if firewall-cmd --state | grep -q running; then
        sudo firewall-cmd --zone=public --add-service=postgresql --permanent
        sudo firewall-cmd --reload
    fi

    # enable PostgreSQL upon reboot:
    sudo systemctl enable postgresql

    # restart PostgreSQL server:
    sudo systemctl start postgresql
    

We can now create a new database user with the necessary access permissions on the new database:

  • on either of the operating systems:

    # create user if it does not exist:
    echo "SELECT 1 FROM pg_roles WHERE rolname='${INVENIO_POSTGRESQL_DBUSER}'" | \
        sudo -i -u postgres psql -tA | grep -q 1 || \
        echo "CREATE USER ${INVENIO_POSTGRESQL_DBUSER} WITH PASSWORD '${INVENIO_POSTGRESQL_DBPASS}';" | \
            sudo -i -u postgres psql

    # create database if it does not exist:
    echo "SELECT 1 FROM pg_database WHERE datname='${INVENIO_POSTGRESQL_DBNAME}'" | \
        sudo -i -u postgres psql -tA | grep -q 1 || \
        echo "CREATE DATABASE ${INVENIO_POSTGRESQL_DBNAME};" | \
            sudo -i -u postgres psql

    # grant privileges to the user on this database:
    echo "GRANT ALL PRIVILEGES ON DATABASE ${INVENIO_POSTGRESQL_DBNAME} TO ${INVENIO_POSTGRESQL_DBUSER};" | \
        sudo -i -u postgres psql
    

Finally, let’s clean after ourselves:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    sudo apt-get -y autoremove && sudo apt-get -y clean
    
  • on CentOS7:

    sudo yum clean -y all
    

2.2.5. Redis

The Redis server (192.168.50.12) is used for various caching needs.

The Redis server can be set up in an automated unattended way by running the following script:

source .inveniorc
./scripts/provision-redis.sh

Let’s see in detail what the Redis provisioning script does.

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    # update list of available packages:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y update

    # install Redis server:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y install \
         redis-server

    # allow network connections:
    if ! grep -q "${INVENIO_REDIS_HOST}" /etc/redis/redis.conf; then
        sudo sed -i "s/bind 127.0.0.1/bind 127.0.0.1 ${INVENIO_REDIS_HOST}/" \
             /etc/redis/redis.conf
    fi

    # restart Redis server:
    sudo /etc/init.d/redis-server restart
    
  • on CentOS 7:

    # add EPEL external repository:
    sudo yum install -y epel-release

    # update list of available packages:
    sudo yum update -y

    # install Redis server:
    sudo yum install -y \
         redis

    # allow network connections:
    if ! grep -q "${INVENIO_REDIS_HOST}" /etc/redis.conf; then
        sudo sed -i "s/bind 127.0.0.1/bind 127.0.0.1 ${INVENIO_REDIS_HOST}/" \
             /etc/redis.conf
    fi

    # open firewall ports:
    if firewall-cmd --state | grep -q running; then
        sudo firewall-cmd --zone=public --add-port=6379/tcp --permanent
        sudo firewall-cmd --reload
    fi

    # enable Redis upon reboot:
    sudo systemctl enable redis

    # start Redis:
    sudo systemctl start redis
    

Finally, let’s clean after ourselves:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    sudo apt-get -y autoremove && sudo apt-get -y clean
    
  • on CentOS7:

    sudo yum clean -y all
    

2.2.6. Elasticsearch

The Elasticsearch server (192.168.50.13) is used to index and search bibliographic records, fulltext documents, and other various interesting information managed by our Invenio digital library instance.

The Elasticsearch server can be set up in an automated unattended way by running the following script:

source .inveniorc
./scripts/provision-elasticsearch.sh

Let’s see in detail what the Elasticsearch provisioning script does.

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    # install curl:
    sudo apt-get -y install curl

    # add external Elasticsearch repository:
    if [[ ! -f /etc/apt/sources.list.d/elasticsearch-2.x.list ]]; then
        curl -sL https://packages.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
        echo "deb http://packages.elastic.co/elasticsearch/2.x/debian stable main" | \
            sudo tee -a /etc/apt/sources.list.d/elasticsearch-2.x.list
    fi

    # update list of available packages:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y update

    # install Elasticsearch server:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y install \
         elasticsearch \
         openjdk-7-jre

    # allow network connections:
    if ! sudo grep -q "network.host: ${INVENIO_ELASTICSEARCH_HOST}" \
         /etc/elasticsearch/elasticsearch.yml; then
        echo "network.host: ${INVENIO_ELASTICSEARCH_HOST}" | \
            sudo tee -a /etc/elasticsearch/elasticsearch.yml
    fi

    # enable Elasticsearch upon reboot:
    sudo update-rc.d elasticsearch defaults 95 10

    # start Elasticsearch:
    sudo /etc/init.d/elasticsearch restart
    
  • on CentOS 7:

    # add external Elasticsearch repository:
    if [[ ! -f /etc/yum.repos.d/elasticsearch.repo ]]; then
        sudo rpm --import \
             https://packages.elastic.co/GPG-KEY-elasticsearch
        echo "[elasticsearch-2.x]
name=Elasticsearch repository for 2.x packages
baseurl=http://packages.elastic.co/elasticsearch/2.x/centos
gpgcheck=1
gpgkey=http://packages.elastic.co/GPG-KEY-elasticsearch
enabled=1" | \
            sudo tee -a /etc/yum.repos.d/elasticsearch.repo
    fi

    # update list of available packages:
    sudo yum update -y

    # install Elasticsearch:
    sudo yum install -y \
         elasticsearch \
         java

    # allow network connections:
    if ! sudo grep -q "network.host: ${INVENIO_ELASTICSEARCH_HOST}" \
         /etc/elasticsearch/elasticsearch.yml; then
        echo "network.host: ${INVENIO_ELASTICSEARCH_HOST}" | \
            sudo tee -a /etc/elasticsearch/elasticsearch.yml
    fi

    # open firewall ports:
    if firewall-cmd --state | grep -q running; then
        sudo firewall-cmd --zone=public --add-port=9200/tcp --permanent
        sudo firewall-cmd --reload
    fi

    # enable Elasticsearch upon reboot:
    sudo systemctl enable elasticsearch

    # start Elasticsearch:
    sudo systemctl start elasticsearch
    

Some packages require extra plugins to be installed.


    $sudo /usr/share/elasticsearch/bin/plugin install -b mapper-attachments
    

Finally, let’s clean after ourselves:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    sudo apt-get -y autoremove && sudo apt-get -y clean
    
  • on CentOS7:

    sudo yum clean -y all
    

2.2.7. RabbitMQ

The RabbitMQ server (192.168.50.14) is used as a messaging middleware broker.

The RabbitMQ server can be set up in an automated unattended way by running the following script:

source .inveniorc
./scripts/provision-rabbitmq.sh

Let’s see in detail what the RabbitMQ provisioning script does.

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    # update list of available packages:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y update

    # install RabbitMQ server:
    sudo DEBIAN_FRONTEND=noninteractive apt-get -y install \
         rabbitmq-server
    
  • on CentOS 7:

    # add EPEL external repository:
    sudo yum install -y epel-release

    # update list of available packages:
    sudo yum update -y

    # install Rabbitmq:
    sudo yum install -y \
         rabbitmq-server

    # open firewall ports:
    if firewall-cmd --state | grep -q running; then
        sudo firewall-cmd --zone=public --add-port=5672/tcp --permanent
        sudo firewall-cmd --reload
    fi

    # enable RabbitMQ upon reboot:
    sudo systemctl enable rabbitmq-server

    # start RabbitMQ:
    sudo systemctl start rabbitmq-server
    

Finally, let’s clean after ourselves:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    sudo apt-get -y autoremove && sudo apt-get -y clean
    
  • on CentOS7:

    sudo yum clean -y all
    

2.2.8. Worker

The Celery worker node (192.168.50.15) is used to execute potentially long tasks in asynchronous manner.

The worker node can be set up in an automated unattended way by running the following script:

source .inveniorc
./scripts/provision-worker.sh

Let’s see in detail what the worker provisioning script does.

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    echo "FIXME worker is a copy of web node"
    
  • on CentOS 7:

    echo "FIXME worker is a copy of web node"
    

Finally, let’s clean after ourselves:

  • on Ubuntu 14.04 LTS (Trusty Tahr):

    sudo apt-get -y autoremove && sudo apt-get -y clean
    
  • on CentOS7:

    sudo yum clean -y all
    

2.2.9. Invenio

Now that all the prerequisites have been set up, we can proceed with the installation of the Invenio itself. The installation is happening on the web node (192.168.50.10).

We start by creating and configuring a new Invenio instance, continue by populating it with some example records, and finally we start the web application. This can be done in an automated unattended way by running the following scripts:

source .inveniorc
./scripts/create-instance.sh
./scripts/populate-instance.sh
./scripts/start-instance.sh

Note

If you want to install the very-bleeding-edge Invenio packages from GitHub, you can run the create-instance.sh script with the --devel argument:

./scripts/create-instance.sh --devel

Let’s see in detail about every Invenio installation step.

2.2.9.1. Create instance

We start by creating a fresh new Python virtual environment that will hold our brand new Invenio v3.0 instance:


mkvirtualenv "${INVENIO_WEB_VENV}"
cdvirtualenv

We continue by installing Invenio v3.0 Integrated Library System flavour demo site from PyPI:


pip install invenio-app-ils[postgresql,elasticsearch2]

Let’s briefly customise our instance with respect to the location of the database server, the Redis server, the Elasticsearch server, and all the other dependent services in our multi-server environment:


mkdir -p "var/instance/"
pip install "jinja2-cli>=0.6.0"
jinja2 "$scriptpathname/instance.cfg" > "var/instance/${INVENIO_WEB_INSTANCE}.cfg"

In the instance folder, we run Npm to install any JavaScript libraries that Invenio needs:


${INVENIO_WEB_INSTANCE} npm
cdvirtualenv "var/instance/static"
CI=true npm install

We can now collect and build CSS/JS assets of our Invenio instance:


${INVENIO_WEB_INSTANCE} collect -v
${INVENIO_WEB_INSTANCE} assets build

Our first new Invenio instance is created and ready for loading some example records.

2.2.9.2. Populate instance

We proceed by creating a dedicated database that will hold persistent data of our installation, such as bibliographic records or user accounts. The database tables can be created as follows:


${INVENIO_WEB_INSTANCE} db init
${INVENIO_WEB_INSTANCE} db create

We continue by creating a user account:


${INVENIO_WEB_INSTANCE} users create \
       "${INVENIO_USER_EMAIL}" \
       --password "${INVENIO_USER_PASS}" \
       --active

We can now create the Elasticsearch indexes and initialise the indexing queue:


${INVENIO_WEB_INSTANCE} index init
sleep 20
${INVENIO_WEB_INSTANCE} index queue init

We proceed by populating our Invenio demo instance with some example demo MARCXML records:


${INVENIO_WEB_INSTANCE} demo init

2.2.9.3. Start instance

Let’s now start the web application:


${INVENIO_WEB_INSTANCE} run -h 0.0.0.0 &

and the web server:


    $sudo service nginx restart
    

We should now see our demo records on the web:

firefox http://${INVENIO_WEB_HOST}/records/1

and we can access them via REST API:

curl -i -H "Accept: application/json" \
     http://${INVENIO_WEB_HOST}/api/records/1

We are done! Our first Invenio v3.0 demo instance is fully up and running.