8. Installationsanleitung

Einleitung

‌Die folgende Installationsanleitung für Goobi workflow bezieht sich auf Ubuntu Linux 16.04. Sie ist als Schritt für Schritt Anleitung von oben nach unten geschrieben, das bedeutet, dass Einstellungen und Konfigurationen aufeinander aufbauen. Wird die Reihenfolge nicht eingehalten, können unter Umständen bestimmte Befehle fehlschlagen.‌

Als Domainname wird in dieser Anleitung GOOBI.EXAMPLE.ORG verwendet und muss an den eigenen DNS Namen angepasst werden.‌

Vorbereitung

‌Zuerst muss man sich auf dem Server, auf dem Goobi workflow installiert werden soll, anmelden und root-Rechte erlangen:

ssh GOOBI.EXAMPLE.ORG
sudo -i

‌Anschließend muss ein Passwort für die Goobi workflow Datenbank generiert und als Variable in der Session abgelegt werden:

export PW_SQL_GOOBI=SECRETPASSWORD

‌Nun müssen die folgenden Pakete installiert werden:

apt -y install git maven

Zum Schluss der Vorbereitung muss ein temporäres Verzeichnis für die Installation angelegt und das Goobi workflow Repository dort hinein geklont werden. In diesem Verzeichnis befinden sich verschiedene Dateien, die für die folgenden Installationsschritte notwendig sind:

install=/tmp/install
mkdir -p $install
cd $install
git clone https://github.com/intranda/goobi.git

‌Es empfiehlt sich zum jetzigen Zeitpunkt bereits über einen DNS-Eintrag für den Server zu verfügen.‌

Variablen und Aliase

‌Folgende Aliase müssen in der Datei /root/.bash_aliases hinzugefügt werden:

cat << "EOF" >/root/.bash_aliases
alias cata='tail -n 1000 -f /var/log/tomcat8/catalina.out'
alias ct='chown tomcat8:tomcat8 *'
alias ctr='chown -R tomcat8:tomcat8 *'
EOF

‌Zur Übernahme der Änderungen in die aktuelle Session muss das folgende Kommando ausgeführt werden:

. /root/.bashrc

Pakete installieren

‌Folgende Pakete sind nun inklusive aller Abhängigkeiten zu installieren:

apt -y install openjdk-8-jdk-headless tomcat8 mariadb-server apache2 slapd libnss-ldapd libldap-2.4-2 ldap-utils ldapvi libpam-ldap smbldap-tools samba smbclient imagemagick graphicsmagick libtiff-tools mailutils djvulibre-bin netpbm jhead exiv2 bc

‌Während der Installation muss ein Passwort für den LDAP Manager Account vergeben werden. In dieser Anleitung wird an den entsprechenden Stellen auf das Passwort mit PW_LDAP_GOOBI verwiesen.‌

Die abgefragte URI für den LDAP-Server lautet:

ldap://127.0.0.1/

‌Die DNS-Einstellungen bei der LDAP-Installation müssen entsprechend den lokalen Gegebenheiten angepasst werden.‌

Konfiguration der Services

LDAP

Konfiguration des LDAP-Servers

‌Als erstes soll der LDAP nur für localhost zuständig sein. Dafür muss in der Datei /etc/default/slapd die Einstellung der SLAPD_SERVICES modifiziert werden:

patch /etc/default/slapd << "EOF"
--- /etc/default/slapd 2016-01-19 14:33:07.000000000 +0100
+++ slapd 2018-03-07 19:54:59.006291228 +0100
@@ -21,7 +21,7 @@
# sockets.
# Example usage:
# SLAPD_SERVICES="ldap://127.0.0.1:389/ ldaps:/// ldapi:///"
-SLAPD_SERVICES="ldap:/// ldapi:///"
+SLAPD_SERVICES="ldap://127.0.0.1:389/ ldapi:///"
# If SLAPD_NO_START is set, the init script will not start or restart
# slapd (but stop will still work). Uncomment this if you are
EOF

‌Anschließend muss das folgende Kommando ausgeführt werden:

dpkg-reconfigure slapd

‌Hierbei muss als DNS-Domainname der komplette Hostname gewählt werden.‌

Danach wird dann der folgende Schritt ausgeführt:

zcat /usr/share/doc/samba/examples/LDAP/samba.schema.gz >> /etc/ldap/schema/samba.schema

‌Die Datei samba.ldif kann dann zu dem Pfad /etc/ldap/schema/ verschoben und das Schema in den LDAP eingefügt werden:

mv $install/goobi/Goobi/install/ldap/samba.ldif /etc/ldap/schema/
ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/ldap/schema/samba.ldif

‌Die Datei import.ldif muss nun bearbeitet werden, um den Wert für dc= an die lokalen Gegebenheiten anzupassen. Anschließend wird dieser Wert ebenfalls importiert:

ldapadd -x -D cn=admin,dc=GOOBI,dc=EXAMPLE,dc=ORG -w PW_LDAP_GOOBI -f $install/goobi/Goobi/install/ldap/import.ldif

‌Danach erfolgt eine Anpassung der Datei /etc/ldap/ldap.conf wie folgt:

cat << "EOF" >/etc/ldap/ldap.conf
#
# LDAP Defaults
#
BASE dc=GOOBI,dc=EXAMPLE,dc=ORG
URI ldap://127.0.0.1
TLS_REQCERT never
EOF

Konfiguration des LDAP-Clients

Die Konfiguration des LDAP-Clients erfolgt folgendermaßen:

patch /etc/ldap.conf << "EOF"
--- /etc/ldap.conf 2018-03-07 20:00:17.174302607 +0100
+++ ldap.conf 2018-03-07 20:22:14.906349732 +0100
@@ -21,7 +21,7 @@
# space. How long nss_ldap takes to failover depends on
# whether your LDAP client library supports configurable
# network or connect timeouts (see bind_timelimit).
-#host 127.0.0.1
+host 127.0.0.1
# The distinguished name of the search base.
base dc=GOOBI,dc=EXAMPLE,dc=ORG
@@ -56,7 +56,7 @@
#port 389
# The search scope.
-#scope sub
+scope sub
#scope one
#scope base
EOF

Außerdem muss in der Datei bei dem Wert rootbinddn der Eintrag cn=manager gegen den Wert cn=admin geändert werden.‌

Konfiguration der Namensauflösung über LDAP

Zur Konfiguration der Namensauflösung muss folgende Anpassung vorgenommen werden.

patch /etc/nsswitch.conf << "EOF"
--- nsswitch.conf 2018-03-07 20:24:03.890353630 +0100
+++ /etc/nsswitch.conf 2018-03-07 20:25:55.654357627 +0100
@@ -4,9 +4,9 @@
# If you have the `glibc-doc-reference' and `info' packages installed, try:
# `info libc "Name Service Switch"' for information about this file.
-passwd: compat
-group: compat
-shadow: compat
+passwd: compat ldap
+group: compat ldap
+shadow: compat ldap
gshadow: files
hosts: files dns
EOF
ldapmodify -Y EXTERNAL -H ldapi:/// -f $install/goobi/Goobi/install/ldap/index.ldif

Verwendung des Tools ldapvi

‌Für die spätere, einfachere Bearbeitung von Werten im LDAP ist ldapvi ein gutes Tool. Dafür müssen die folgenden Einträge in der Datei /etc/ldapvi.conf angepasst und eingefügt werden:

echo 'user: cn=admin,dc=GOOBI,dc=EXAMPLE,dc=ORG' >>/etc/ldapvi.conf
echo 'password: PW_LDAP_GOOBI' >>/etc/ldapvi.conf
chmod 600 /etc/ldapvi.conf

Einrichtung von Samba

Der Samba-Server ist an den LDAP angebunden. Die Konfigurationsdatei muss dafür mit derjenigen aus dem Repository ersetzt werden und anschließend die LDAP-Konfiguration angepasst werden:

mv $install/goobi/Goobi/install/samba/smb.conf /etc/samba/smb.conf
vim /etc/samba/smb.conf

Samba benötigt hierzu das Passwort für den LDAP Admin:

smbpasswd -w PW_LDAP_GOOBI

Achtung Samba unterscheidet bei den Usernamen nicht zwischen Groß-/Kleinschreibung!‌

Falls mit Samba die von Goobi workflow erstellten symbolischen Links nicht gesehen werden, muss in dem Abschnitt [homes] der Eintrag guest ok = yes angepasst werden. Dabei ist darauf zu achten, dass Samba wirklich nur für ein internes Netzwerk freigeschaltet wurde.

systemctl restart smbd

Samba: Anzeige des freien Speichers

Der Upload der Images erfolgt üblicherweise innerhalb des Verzeichnispfades /opt/digiverso. Deshalb soll Samba auch den freien Speicher von dort anzeigen:

mv $install/goobi/Goobi/install/samba/samba-dfree /usr/local/bin/samba-dfree
chmod 755 /usr/local/bin/samba-dfree

Einrichtung der Datenbank MySQL / MariaDB

‌Goobi workflow benötigt eine Datenbank und einen eigenen Nutzer. Mit dem folgenden Kommando wird ebenfalls das Datenbankschema importiert und eine initiale Struktur angelegt:

mysql -e "CREATE DATABASE goobi;
USE goobi;
SOURCE $install/goobi/Goobi/install/db/goobi_blank.sql;
CREATE USER 'goobi'@'localhost' IDENTIFIED BY '$PW_SQL_GOOBI';
GRANT ALL PRIVILEGES ON goobi.* TO 'goobi'@'localhost' WITH GRANT OPTION;
FLUSH PRIVILEGES;"

Einrichtung des Tomcat Servers

In der Datei /etc/default/tomcat8 sollte der Speicher unter -Xmx dem verfügbaren Maschinenspeicher angepasst werden. Auch werden die zu verwendenden Garbage Collector Optionen ausgewählt und urandom für einen schnelleren Tomcat-Start konfiguriert:

patch /etc/default/tomcat8 << "EOF"
--- /etc/default/tomcat8 2018-03-01 19:11:46.947240791 +0000
+++ tomcat8 2018-03-01 19:14:01.920680439 +0000
@@ -18,7 +18,13 @@
# response time). If you use that option and you run Tomcat on a machine with
# exactly one CPU chip that contains one or two cores, you should also add
# the "-XX:+CMSIncrementalMode" option.
-JAVA_OPTS="-Djava.awt.headless=true -Xmx128m -XX:+UseConcMarkSweepGC"
+JAVA_OPTS="-Djava.awt.headless=true -Xmx4g -Xms2g"
+JAVA_OPTS="${JAVA_OPTS} -XX:+UseG1GC"
+JAVA_OPTS="${JAVA_OPTS} -XX:+ParallelRefProcEnabled"
+JAVA_OPTS="${JAVA_OPTS} -XX:+DisableExplicitGC"
+JAVA_OPTS="${JAVA_OPTS} -XX:+CMSClassUnloadingEnabled"
+JAVA_OPTS="${JAVA_OPTS} -Djava.security.egd=file:/dev/./urandom"
+JAVA_OPTS="${JAVA_OPTS} -Dfile.encoding='utf-8'"
# To enable remote debugging uncomment the following line.
# You will then be able to use a java debugger on port 8000.
@@ -32,9 +39,9 @@
#TOMCAT8_SECURITY=no
# Number of days to keep logfiles in /var/log/tomcat8. Default is 14 days.
-#LOGFILE_DAYS=14
+LOGFILE_DAYS=14
# Whether to compress logfiles older than today's
-#LOGFILE_COMPRESS=1
+LOGFILE_COMPRESS=1
# Location of the JVM temporary directory
# WARNING: This directory will be destroyed and recreated at every startup !
EOF

‌In der Datei /etc/tomcat8/server.xml werden mit dem Parameter appContextProtection der JreMemoryLeakPreventionListener ausgeschaltet, der Tomcat nur für localhost konfiguriert und für den Proxy entsprechende Connectoren eingerichtet:

patch /etc/tomcat8/server.xml << "EOF"
--- /etc/tomcat8/server.xml 2017-09-28 14:56:31.000000000 +0100
+++ server.xml 2018-03-01 19:18:50.143658964 +0000
@@ -29,7 +29,7 @@
<Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
-->
<!-- Prevent memory leaks due to use of particular java/javax APIs-->
- <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
+ <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" appContextProtection="false" />
<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
<Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
@@ -68,33 +68,19 @@
APR (HTTP/AJP) Connector: /docs/apr.html
Define a non-SSL/TLS HTTP/1.1 Connector on port 8080
-->
- <Connector port="8080" protocol="HTTP/1.1"
- connectionTimeout="20000"
- URIEncoding="UTF-8"
- redirectPort="8443" />
- <!-- A "Connector" using the shared thread pool-->
- <!--
- <Connector executor="tomcatThreadPool"
- port="8080" protocol="HTTP/1.1"
- connectionTimeout="20000"
- redirectPort="8443" />
- -->
- <!-- Define a SSL/TLS HTTP/1.1 Connector on port 8443
- This connector uses the NIO implementation that requires the JSSE
- style configuration. When using the APR/native implementation, the
- OpenSSL style configuration is required as described in the APR/native
- documentation -->
- <!--
- <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
- maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
- clientAuth="false" sslProtocol="TLS" />
- -->
-
- <!-- Define an AJP 1.3 Connector on port 8009 -->
- <!--
- <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
- -->
-
+<Connector address="127.0.0.1" port="8080" protocol="HTTP/1.1"
+ connectionTimeout="20000"
+ maxThreads="400"
+ URIEncoding="UTF-8"
+ enableLookups="false"
+ disableUploadTimeout="true"
+ proxyName="GOOBI.EXAMPLE.ORG"
+ proxyPort="80" />
+
+<Connector address="127.0.0.1" port="8009" protocol="AJP/1.3"
+ connectionTimeout="20000"
+ maxThreads="400"
+ URIEncoding="UTF-8" />
<!-- An Engine represents the entry point (within Catalina) that processes
every request. The Engine implementation for Tomcat stand alone
EOF

‌Anschließend wird noch die Sessionpersistenz innerhalb der Datei /etc/tomcat8/context.xml deaktiviert, indem die folgende Zeile einkommentiert wird:

patch /etc/tomcat8/context.xml << "EOF"
--- /etc/tomcat8/context.xml 2014-01-24 17:17:30.000000000 +0000
+++ context.xml 2018-03-01 19:23:05.166223891 +0000
@@ -24,9 +24,7 @@
<WatchedResource>${catalina.base}/conf/web.xml</WatchedResource>
<!-- Uncomment this to disable session persistence across Tomcat restarts -->
- <!--
<Manager pathname="" />
- -->
<!-- Uncomment this to enable Comet connection tacking (provides events
on session expiration as well as webapp lifecycle) -->
EOF

Konfiguration des Apache

Der Webserver Apache muss eingerichtet werden, um Goobi workflow extern zur Verfügung zu stellen. Dafür werden die folgenden Module aktiviert:

a2enmod proxy_ajp
a2enmod rewrite
a2enmod headers

‌Die folgende Datei muss unter folgendem Pfad gespeichert werden /etc/apache2/sites-available/GOOBI.EXAMPLE.ORG.conf:

cat << "EOF" >/etc/apache2/sites-available/GOOBI.EXAMPLE.ORG.conf
<VirtualHost *:80>
ServerAdmin support@intranda.com
ServerName GOOBI.EXAMPLE.ORG
DocumentRoot /var/www
RequestHeader unset Expect early
## compress output
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/plain text/html text/xml
AddOutputFilterByType DEFLATE text/css text/javascript
AddOutputFilterByType DEFLATE application/xml application/xhtml+xml
AddOutputFilterByType DEFLATE application/rss+xml
AddOutputFilterByType DEFLATE application/javascript application/x-javascript
</IfModule>
## general proxy settings
ProxyPreserveHost On
ProxyVia On
SetEnv force-proxy-request-1.0 1
SetEnv proxy-nokeepalive 1
<Proxy *>
Require local
</Proxy>
## goobi
redirect /index.html http://GOOBI.EXAMPLE.ORG/goobi/
redirectmatch /goobi$ http://GOOBI.EXAMPLE.ORG/goobi/
<Location /goobi/>
Require all granted
ProxyPass ajp://localhost:8009/goobi/ retry=0
ProxyPassReverse ajp://localhost:8009/goobi/
</Location>
## disable external connection to Goobi WebAPI globally
# ProxyPass /goobi/wi !
## only allow access to Goobi WebAPI for certain hosts
<Location /goobi/wi>
# Require ip 1.2.3.4
Require local
</Location>
## logging
CustomLog /var/log/apache2/GOOBI.EXAMPLE.ORG_access.log combined
ErrorLog /var/log/apache2/GOOBI.EXAMPLE.ORG_error.log
# Possible values include: debug, info, notice, warn, error, crit, alert, emerg.
LogLevel warn
</VirtualHost>
EOF

‌Der Goobi workflow vhost wird nun aktiviert, der default vhost deaktiviert und der Apache Webserver neu gestartet:

a2dissite 000-default.conf
a2ensite GOOBI.EXAMPLE.ORG.conf
systemctl restart apache2

Einrichtung von sudo

Goobi workflow benötigt für das Ausführen von Skripten verschiedene Rechte. Dafür muss die folgende Datei für die sudo Rechte abgelegt werden:

cat << "EOF" | EDITOR='tee' visudo -f /etc/sudoers.d/70_goobi
##
# Goobi sudoers file
##
# Berechtigungen fuer Tomcat Server
User_Alias HTTPD=tomcat8
# In den Shellscripten definierte Kommandos:
# script_chownTomcat.sh, script_chownUser.sh, script_createDirUserHome.sh,
# script_createSymLink.sh
Cmnd_Alias CHOWN_DATEN=/bin/chown * /opt/digiverso/goobi/metadata/*
# script_createDirUserHome.sh
Cmnd_Alias CHGRP_USERS=/bin/chgrp tomcat8 /home/*
Cmnd_Alias CHMOD_USERS=/bin/chmod g+w /home/*
Cmnd_Alias CHMOD_WRITE=/bin/chmod * /opt/digiverso/goobi/metadata/*
Cmnd_Alias CHOWN_USERS=/bin/chown * /home/*
Cmnd_Alias MKDIR_USERS=/bin/mkdir /home/*
# Der Tomcat Server darf die in den Shellscripten definierten Kommandos ohne
# Passwortabfrage mit root Berechtigung ausfuehren
HTTPD ALL=NOPASSWD: CHOWN_DATEN, CHGRP_USERS, CHMOD_USERS, CHOWN_USERS, MKDIR_USERS, CHMOD_WRITE
HTTPD ALL=NOPASSWD: /bin/mount --bind /opt/digiverso/goobi/metadata/* /home/*
HTTPD ALL=NOPASSWD: /bin/umount -l /home/*
HTTPD ALL=NOPASSWD: /bin/rmdir /home/*
HTTPD ALL=NOPASSWD: /bin/chmod * /home/*
EOF

Einrichtung von NFS

Die Einrichtung von NFS ist nur dann relevant, wenn der Goobi viewer ebenfalls installiert ist oder installiert werden soll, und diese Installation nicht auf der gleichen Maschine erfolgt.

In diesem Falle muss der Ordner /opt/digiverso/viewer von dem Goobi viewer Server exportiert und im Goobi workflow Server eingehängt werden. Die Anpassungen dafür lauten folgendermaßen:

export IP_VIEWER=1.2.3.4 # IP-Adresse des Goobi viewer Servers
apt install -y nfs-common
mkdir /opt/digiverso/viewer/hotfolder -p
chown root:root /opt/digiverso/viewer/hotfolder
echo "${IP_VIEWER}:/opt/digiverso/viewer/hotfolder /opt/digiverso/viewer/hotfolder nfs rsize=8192,wsize=8192,soft,intr,rw,nolock,auto 0 0" >> /etc/fstab

Erstellung der Verzeichnisstruktur

‌Mit den nachfolgenden Befehlen wird die notwendige Ordnerstruktur erzeugt und die Dateien aus dem Repository an die erwartete Stelle verschoben:

mkdir -p /opt/digiverso/{logs,tomcat-lib,goobi/{activemq,config,lib,metadata,rulesets,scripts,static_assets,tmp,xslt,plugins/{administration,command,dashboard,export,GUI,import,opac,statistics,step,validation,workflow}}}
mv $install/goobi/Goobi/install/config/* /opt/digiverso/goobi/config/
mv $install/goobi/Goobi/install/scripts/* /opt/digiverso/goobi/scripts/
mv $install/goobi/Goobi/install/rulesets/* /opt/digiverso/goobi/rulesets/
mv $install/goobi/Goobi/install/xslt/* /opt/digiverso/goobi/xslt/
chown -R tomcat8: /opt/digiverso/

‌Außerdem wird für die Bildanzeige noch Java Advanced Imaging (JAI) installiert:

cd $install
wget http://www.java2s.com/Code/JarDownload/jai/jai_codec-1.1.2_01.jar.zip
wget http://www.java2s.com/Code/JarDownload/jai/jai_core-1.1.2_01.jar.zip
wget http://www.java2s.com/Code/JarDownload/jai/jai_imageio-1.1.jar.zip
apt install unzip
for i in *.zip; do unzip $i; done
mv $install/jai_*.jar /opt/digiverso/tomcat-lib/

‌Deployment von Goobi workflow

‌Für das Deployment von Goobi workflow wird der Tomcat Dienst wie folgt gestoppt:

systemctl stop tomcat8

‌Danach muss die folgende Datei unter dem Pfad /etc/tomcat8/Catalina/localhost/goobi.xml abgelegt werden:

sed -e "s/PW_SQL_GOOBI/$PW_SQL_GOOBI/" << "EOF" >/etc/tomcat8/Catalina/localhost/goobi.xml
<?xml version='1.0' encoding='utf-8'?>
<Context>
<Manager className="org.apache.catalina.session.PersistentManager" distributable="false" saveOnRestart="false">
<Store className="org.apache.catalina.session.FileStore"/>
</Manager>
<Resources>
<PreResources
className="org.apache.catalina.webresources.DirResourceSet"
base="/opt/digiverso/tomcat-lib/"
webAppMount="/WEB-INF/lib" />
<PreResources
className="org.apache.catalina.webresources.DirResourceSet"
base="/opt/digiverso/goobi/plugins/GUI/"
webAppMount="/WEB-INF/lib" />
<PostResources
className="org.apache.catalina.webresources.DirResourceSet"
base="/opt/digiverso/goobi/lib/"
webAppMount="/WEB-INF/lib" />
</Resources>
<Resource name="goobi"
auth="Container"
factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
username="goobi"
password="PW_SQL_GOOBI"
maxActive="100"
maxIdle="30"
minIdle="4"
maxWait="10000"
testOnBorrow="true"
testWhileIdle="true"
validationQuery="SELECT SQL_NO_CACHE 1"
removeAbandoned="true"
removeAbandonedTimeout="600"
url="jdbc:mysql://localhost/goobi?characterEncoding=UTF-8&amp;autoReconnect=true&amp;autoReconnectForPools=true" />
</Context>
EOF

Nun werden die Dateirechte so angepasst, dass die Datei bei einem Update nicht mit gelöscht wird:

chown -R root.tomcat8 /etc/tomcat8/Catalina
chmod -R g-w /etc/tomcat8/Catalina

Im folgenden wird Goobi workflow nun kompiliert und an die erwartete Stelle im Dateisystem verschoben:

cd $install/goobi/Goobi/
mvn package
mv $install/goobi/Goobi/module-war/target/goobi.war /var/lib/tomcat8/webapps/

Deployment von Plugins

‌Für die Inbetriebnahme einige Plugins müssen diese ebenfalls kompiliert und an die erwartete Stelle im Dateisystem verschoben werden:

# OPAC: PICA
cd $install
git clone https://github.com/intranda/goobi-plugin-opac-pica.git
cd $install/goobi-plugin-opac-pica/PicaOpacPlugin
mvn package
mv $install/goobi-plugin-opac-pica/PicaOpacPlugin/target/plugin_intranda_opac_pica.jar /opt/digiverso/goobi/plugins/opac/
# OPAC: MARC
cd $install
git clone https://github.com/intranda/goobi-plugin-opac-marc.git
cd $install/goobi-plugin-opac-marc/goobi-plugin-opac-marc
mvn package
mv $install/goobi-plugin-opac-marc/goobi-plugin-opac-marc/module-main/target/plugin_intranda_opac_marc.jar /opt/digiverso/goobi/plugins/opac/
# Step: Fileupload
cd $install
git clone https://github.com/intranda/goobi-plugin-step-fileupload.git
cd $install/goobi-plugin-step-fileupload/goobi-plugin-step-fileupload
mvn package
mv $install/goobi-plugin-step-fileupload/goobi-plugin-step-fileupload/module-main/target/plugin_intranda_step_fileUpload.jar /opt/digiverso/goobi/plugins/step/
mv $install/goobi-plugin-step-fileupload/goobi-plugin-step-fileupload/plugin_intranda_step_fileUpload.xml /opt/digiverso/goobi/config
mv $install/goobi-plugin-step-fileupload/goobi-plugin-step-fileupload/module-gui/target/plugin_intranda_step_fileUpload-GUI.jar /opt/digiverso/goobi/plugins/GUI/
# Step: ImageQA
cd $install
git clone https://github.com/intranda/goobi-plugin-step-imageqa.git
cd $install/goobi-plugin-step-imageqa/ImageQAPlugin/
mvn package
mv $install/goobi-plugin-step-imageqa/ImageQAPlugin/plugin_intranda_step_imageQA.xml /opt/digiverso/goobi/config
mv $install/goobi-plugin-step-imageqa/ImageQAPlugin/module-gui/target/plugin_intranda_step_imageQA-GUI.jar /opt/digiverso/goobi/plugins/GUI/
mv $install/goobi-plugin-step-imageqa/ImageQAPlugin//module-main/target/plugin_intranda_step_imageQA.jar /opt/digiverso/goobi/plugins/step/
# Command: intranda WebAPI
cd $install
git clone https://github.com/intranda/goobi-plugin-command-intranda.git
cd $install/goobi-plugin-command-intranda/goobi-plugin-command-intranda
mvn package
mv $install/goobi-plugin-command-intranda/goobi-plugin-command-intranda/target/plugin_intranda_command_default.jar /opt/digiverso/goobi/plugins/command/
# Dashboard: Example
cd $install
git clone https://github.com/intranda/goobi-plugin-dashboard-example.git
cd $install/goobi-plugin-dashboard-example/DashboardPlugins
mvn package
mv $install/goobi-plugin-dashboard-example/DashboardPlugins/module-gui/target/plugin_intranda_dashboard_example-GUI.jar /opt/digiverso/goobi/plugins/GUI/
mv $install/goobi-plugin-dashboard-example/DashboardPlugins/module-main/target/plugin_intranda_dashboard_example.jar /opt/digiverso/goobi/plugins/dashboard/
mv $install/goobi-plugin-dashboard-example/DashboardPlugins/plugin_intranda_dashboard_extended.xml /opt/digiverso/goobi/config/
mv $install/goobi-plugin-dashboard-example/DashboardPlugins/plugin_intranda_dashboard_simple.xml /opt/digiverso/goobi/config/
# REST: intranda REST
cd $install
git clone https://github.com/intranda/goobi-plugin-rest-intranda.git
cd $install/goobi-plugin-rest-intranda/goobi-plugin-rest-intranda
mvn package
mv $install/goobi-plugin-rest-intranda/goobi-plugin-rest-intranda/target/plugin_intranda_rest_default.jar /opt/digiverso/goobi/lib/
# Controlling: intranda default statistics
cd $install
git clone https://github.com/intranda/goobi-plugin-controlling-intranda.git
cd $install/goobi-plugin-controlling-intranda/intrandaStatisticPlugins/
mvn package
mv $install/goobi-plugin-controlling-intranda/intrandaStatisticPlugins/statistics_template.pdf /opt/digiverso/goobi/plugins/statistics/
mv $install/goobi-plugin-controlling-intranda/intrandaStatisticPlugins/statistics_template.xls /opt/digiverso/goobi/plugins/statistics/
mv $install/goobi-plugin-controlling-intranda/intrandaStatisticPlugins/module-gui/target/plugin_intranda_statistics-GUI.jar /opt/digiverso/goobi/plugins/GUI/
mv $install/goobi-plugin-controlling-intranda/intrandaStatisticPlugins/module-main/target/plugin_intranda_statistics.jar /opt/digiverso/goobi/plugins/statistics/

‌Im Anschluß daran kann der Tomcat-Dienst erneut gestartet werden:

systemctl start tomcat8

Konfigurationen und Einstellungen

Grundsätzlich ist darauf zu achten, dass Kommata in den Konfigurationsdateien mit einem Backslash escaped werden müssen:

# Falsch:
ldap_adminLogin=cn=admin,dc=GOOBI,dc=EXAMPLE,dc=ORG
<institution>Name, Place</institution>
# Richtig:
ldap_adminLogin=cn=admin\,dc=GOOBI\,dc=EXAMPLE\,dc=ORG
<institution>Name\, Place</institution>

Konfigurationsdatei: goobi_config.properties

‌In der lokalen Goobi workflow Konfigurationsdatei wird die LDAP Anbindung wie folgt konfiguriert:

/opt/digiverso/goobi/config/goobi_config.properties
# LDAP
ldap_use=true
ldap_nextFreeUnixId=cn=NextFreeUnixId\,dc=GOOBI\,dc=EXAMPLE\,dc=ORG
ldap_adminLogin=cn=admin\,dc=GOOBI\,dc=EXAMPLE\,dc=ORG
ldap_adminPassword=PW_LDAP_GOOBI
ldap_readonly=false

Benutzer in LDAP anlegen

Die Test-Accounts müssen in den LDAP geschrieben werden. Dabei ist zu beachten, dass dn, sambaPrimaryGroupSID und sambaSID in der Dateitestuser.ldif angepasst werden:

SID=$(sudo net getlocalsid | awk '{print $NF}'); echo $SID #SID herausfinden
vim $install/goobi/Goobi/install/ldap/testuser.ldif
ldapadd -x -D cn=admin,dc=GOOBI,dc=EXAMPLE,dc=ORG -w PW_LDAP_GOOBI -f $install/goobi/Goobi/install/ldap/testuser.ldif

Die Homeverzeichnisse für die Nutzer werden folgendermaßen angelegt:

cd /home && for i in testadmin testscanning testmetadata testimaging testqc testprojectmanagement ; do mkdir $i; chown $i:tomcat8 $i; chmod 775 $i; done

Darüber hinaus wird für Goobi workflow die SID geändert und der Wert für userDN angepasst:

mysql goobi -e "update ldapgruppen set sambaSID='$SID-{uidnumber*2+1000}', sambaPrimaryGroupSID='$SID-100' where ldapgruppenid=2;"
mysql goobi -e 'update ldapgruppen set userDN="cn={login},ou=users,ou=goobi,dc=GOOBI,dc=EXAMPLE,dc=ORG" where ldapgruppenID=2;'

Mit dem Account testadmin ist nun ein Einloggen möglich. Innerhalb des Menüpunktes Administration -> Benutzer können nun weitere Accounts angelegt werden. Diese müssen anschließend entsprechend den jeweiligen Benutzergruppen und Projekten zugeordnet werden.

Ein Test des SMB-Zugriffs kann so getestet werden:

smbclient -U testadmin%test //localhost/testadmin

Achtung: Bitte beachten Sie, dass Sie die wichtigen Passwörter und Zugangsinformationen an geeigneter Stelle sicher dokumentieren.

Konfigurationsdatei: goobi_opac.xml

‌In der Datei goobi_opac.xml kann der verwendete Katalog eingetragen oder angepasst werden:

/opt/digiverso/goobi/config/goobi_opac.xml
<?xml version="1.0" encoding="UTF-8"?>
<opacCatalogues>
[...]
<catalogue title="K10Plus">
<config address="kxp.k10plus.de" database="2.1" description="K10plus" iktlist="IKTLIST-GBV.xml" port="80" ucnf="UCNF=NFC&amp;XPNOFF=1" />
</catalogue>
</opacCatalogues>

Konfigurationsdatei: goobi_projects.xml

‌In der Konfigurationsdatei goobi_projects.xml werden verschiedene wichtige Parameter für das Erzeugen von Vorgängen festgelegt. Dies betrifft unter anderem den Einrichtungsnamen, das aktuelle Jahr oder auch den standardmäßig verwendeten Katalog:

/opt/digiverso/goobi/config/goobi_projects.xml
<?xml version="1.0" encoding="UTF-8"?>
<goobiProjects>
<project name="default">
<createNewProcess>
<itemlist>
<item from="werk" multiselect="true">
Creator of digital edition
<select label="Library of Congress (LoC)">Library of Congress</select>
</item>
[...]
<item docstruct="topstruct" isnotdoctype="periodical|multivolume" metadata="_dateDigitization" multiselect="true" required="true" ughbinding="true">
Digitisation date
<select label="2029">2019</select>
</item>
[...]
</itemlist>
<opac use="true">
<catalogue>Library of Congress</catalogue>
</opac>
</createNewProcess>
</project>
</goobiProjects>

Konfigurationsdatei: goobi_digitalCollections.xml

‌In der Konfigurationsdatei goobi_digitalCollections.xml können für das angelegte Beispielprojekt verschiedene Kollektionen angepasst werden. Beispielhaft könnte dies so aussehen:

/opt/digiverso/goobi/config/goobi_digitalCollections.xml
<?xml version="1.0" encoding="UTF-8"?>
<DigitalCollections>
<default>
<DigitalCollection>DefaultCollection</DigitalCollection>
</default>
<project>
<name>sample_project</name>
<DigitalCollection>Monograph</DigitalCollection>
<DigitalCollection>Varia</DigitalCollection>
</project>
</DigitalCollections>