en	Backup and Restore
nl	Backup en Herstel

en	OTOBO has built in scripts for backup and restore. Execute the scripts with the option ``-h`` for more information.
nl	OTOBO heeft ingebouwde scripts voor backup en herstel. Voer de scripts uit met de optie ``-h`` voor meer informatie.

en	Backup

en	To create a new backup, write permission for the destination directory is needed for the user ``otobo``.
nl	Om een nieuwe backup te maken, is schrijfrechten voor de bestemmingsmap nodig voor de gebruiker ``otobo``.

en	The output of the script:
nl	De uitvoer van het script:

en	Restore
nl	Herstellen

en	To restore the database make sure that the database ``otobo`` exists and contains no tables.
nl	Om de database te herstellen, zorg ervoor dat de database ``otobo`` bestaat en geen tabellen bevat.

en	Considerations for running OTOBO under Docker
nl	Overwegingen voor het draaien van OTOBO onder Docker

en	The same scripts can be used with OTOBO running under Docker. However some Docker specific limitation must be considered. Please read to the chapter :doc:`backup-restore-docker` for information about that case.
nl	Dezelfde scripts kunnen worden gebruikt met OTOBO draaiend onder Docker. Echter moeten enkele Docker-specifieke beperkingen in acht worden genomen.

en	Backup and Restore using Docker
nl	Backup en Herstel met Docker

en	Please read to the chapter :doc:`backup-restore` for basic information about the backup and restore scripts.
nl	Lees alstublieft het hoofdstuk :doc:`backup-restore` voor basisinformatie over de backup- en herstelscripts.

en	The standard scripts ``backup.pl`` and ``restore.pl`` can also be used with OTOBO running under Docker. However some Docker specific limitations have to be considered.
nl	De standaardscripts ``backup.pl`` en ``restore.pl`` kunnen ook gebruikt worden met OTOBO draaiend onder Docker. Echter moeten enkele Docker-specifieke beperkingen in acht genomen worden.

en	First, we need to make sure that the backup files are not created in the file system that is internal to a Docker container. Because in that case the created files would be lost when the container is stopped. This means that the backup directory must located within in a volume. For this manual we only consider the most simple case, where the backup directory is a local directory on the Docker host. The location of the backup dir in the container can be arbitrarily chosen. In this example we choose the local dir ``otobo_backup`` as the location on the host and ``/otobo_backup`` as the location in the container.
nl	Eerst moeten we ervoor zorgen dat de back-upbestanden niet worden gemaakt in het bestandssysteem dat intern is aan een Docker-container. Want in dat geval zouden de gecreëerde bestanden verloren gaan wanneer de container wordt gestopt. Dit betekent dat de back-upmap zich binnen een volume moet bevinden. Voor deze handleiding beschouwen we alleen het meest eenvoudige geval, waarbij de back-upmap een lokale map is op de Docker-host. De locatie van de back-upmap in de container kan willekeurig gekozen worden. In dit voorbeeld kiezen we de lokale map ``otobo_backup`` als locatie op de host en ``/otobo_backup`` als locatie in de container.

en	Secondly, commands in the Docker container usually run as the user `otobo` with the user id 1000 and the group id 1000. It must be made sure, that this user can write in the backup directory.
nl	Ten tweede moeten commando's in de Docker-container meestal worden uitgevoerd als de gebruiker `otobo` met gebruikers-ID 1000 en groeps-ID 1000. Er moet voor worden gezorgd dat deze gebruiker kan schrijven in de back-upmap.

en	First we need to create the volume.
nl	Eerst moeten we het volume aanmaken.

en	For creating the backup we need a running database and the volumes ``otobo_opt_otobo`` and ``otobo_backup``. This means that the webserver and the OTOBO daemon may, but don't have to, be stopped.
nl	Voor het maken van de back-up hebben we een draaiende database en de volumes ``otobo_opt_otobo`` en ``otobo_backup`` nodig. Dit betekent dat de webserver en de OTOBO-daemon wel gestopt mogen worden, maar dat hoeft niet.

en	To drop an existing otobo database and create a new one you can use the following commands. First, you have to connect to the MySQL CLI of the `db` container.
nl	Om een bestaande otobo-database te verwijderen en een nieuwe aan te maken, kun je de volgende commando's gebruiken. Eerst moet je verbinding maken met de MySQL CLI van de `db` container.

en	As soon as you are connected to the MySQL server, you can drop and recreate the `otobo` database.
nl	Zodra je verbonden bent met de MySQL-server, kun je de `otobo` database verwijderen en opnieuw aanmaken.

en	For restoring the backup we also need to specify which backup should be restored. The placeholder ``<TIMESTAMP>`` is something like ``2020-09-07_09-38``.
nl	Om de backup te herstellen moeten we ook specificeren welke backup hersteld moet worden. De placeholder ``<TIMESTAMP>`` is zoiets als ``2020-09-07_09-38``.

en	Adapt customer interface with corporate identity
nl	Pas de klanteninterface aan met de huisstijl van het bedrijf

en	In OTOBO it is very easy to adapt the customer area to your own corporate identity. Follow this tutorial step by step and OTOBO will shine in your own design in a short time.
nl	In OTOBO is het heel eenvoudig om het klantengebied aan te passen aan je eigen huisstijl. Volg deze tutorial stap voor stap en OTOBO zal in korte tijd stralen in je eigen ontwerp.

en	Currently, it is not so easy to adapt the agent area to one's own CI. Changes in the OTOBO .css files would be necessary here. One exception is the logo on the agent login page and the agent header. The logos can be easily exchanged by copying the logos to the server and then adjusting the options ``AgentLoginLogo`` and ``AgentLogo`` under ``Admin -> System Configuration``.
nl	Momenteel is het niet zo eenvoudig om het agentgebied aan te passen aan je eigen CI. Wijzigingen in de OTOBO .css-bestanden zouden hier nodig zijn. Een uitzondering is het logo op de inlogpagina van de agent en de agent header. De logo's kunnen gemakkelijk worden uitgewisseld door de logo's naar de server te kopiëren en vervolgens de opties ``AgentLoginLogo`` en ``AgentLogo`` aan te passen onder ``Admin -> Systeemconfiguratie``.

en	Change colors in Customer Area
nl	Kleuren wijzigen in Klantengebied

en	To change the colors for the OTOBO customer interface, please go to ``Admin -> System Configuration`` and change the following settings:
nl	Om de kleuren voor de OTOBO klanteninterface te wijzigen, ga naar ``Admin -> Systeemconfiguratie`` en wijzig de volgende instellingen:

en	CustomerColorDefinitions
nl	KlantKleurDefinities

en	To change the colours on the Customer Dashboard, please go to `Admin -> System Configuration`` and search for CustomerDashboard. In the search result you will find all the options you need with colour definitions.
nl	Om de kleuren op het klantendashboard te wijzigen, ga je naar `Admin -> Systeemconfiguratie`` en zoek je naar CustomerDashboard. In de zoekresultaten vind je alle opties die je nodig hebt met kleurdefinities.

en	Change Logos and Pictures
nl	Logo's en afbeeldingen wijzigen

en	In the first step please copy your Logos and Pictures to the OTOBO Server. Please use an SCP client (WinSCP) for this purpose. Often you do not have the permissions to copy the logos to the right place. In this case, it is best to use the folder /tmp/.
nl	Kopieer in de eerste stap je logo's en afbeeldingen naar de OTOBO-server. Gebruik hiervoor een SCP-client (WinSCP). Vaak heb je niet de rechten om de logo's naar de juiste plek te kopiëren. In dat geval kun je het beste de map /tmp/ gebruiken.

en	In the next step copy the Logo into the OTOBO Home directory:
nl	Kopieer in de volgende stap het logo naar de OTOBO-hoofdmap:

en	Now change inside the OTOBO Agent Interface to ``Admin -> System Configuration`` and change the following settings:
nl	Ga nu in de OTOBO Agent Interface naar ``Admin -> Systeemconfiguratie`` en wijzig de volgende instellingen:

en	Change Customer Login Pictures and Text
nl	Klantloginafbeeldingen en -tekst wijzigen

en	1 and 2 - System Configuration Option **CustomerLogin::Settings**
nl	1 en 2 - Systeemconfiguratieoptie **CustomerLogin::Settings**

en	**Remove Opacity and Watermark**
nl	**Verwijder Doorzichtigheid en Watermerk**

en	At the moment it is not possible to remove the overlay and watermark used in the image on the right by system configuration.
nl	Op dit moment is het niet mogelijk om de overlay en het watermerk gebruikt in de afbeelding aan de rechterkant te verwijderen via systeemconfiguratie.

en	To remove the opacity, please adjust the option **#oooLoginBG > .oooBG** in the file
nl	Om de doorzichtigheid te verwijderen, pas de optie **#oooLoginBG > .oooBG** aan in het bestand

en	``var/httpd/htdocs/skins/Customer/default/css/Core.Login.css``

en	To remove the watermark, please remove the following line inside the file:
nl	Om het watermerk te verwijderen, verwijder de volgende regel binnen het bestand:

en	``Kernel/Output/HTML/Templates/Standard/CustomerLogin.tt``

en	Please add the files to a opm package in the next step, so that the changes remain persistent. You can find instructions on how to do this in our Admin Manual: https://doc.otobo.org/manual/developer/11.0/en/content/how-to-publish-otobo-extensions.html
nl	Voeg de bestanden in de volgende stap toe aan een opm-pakket, zodat de wijzigingen blijvend zijn. Instructies over hoe dit te doen vind je in onze Admin Handleiding: https://doc.otobo.org/manual/developer/10.1/en/content/how-to-publish-otobo-extensions.html

en	Change Customer Dashboard tiles and options
nl	Pas de tegels en opties van het klantendashboard aan

en	To change the colours on the Customer Dashboard, please go to ``Admin -> System Configuration`` and search for **CustomerDashboard**.
nl	Om de kleuren op het Klantendashboard te wijzigen, ga je naar ``Admin -> Systeemconfiguratie`` en zoek je naar **CustomerDashboard**.

en	In the search result you will find all the options you need with colour definitions.
nl	In het zoekresultaat vind je alle opties die je nodig hebt met kleurdefinities.

en	1 - To change the picture, link and text please use the System Configuration Option **CustomerDashboard::Tiles###FeaturedLink-01**
nl	1 - Om de afbeelding, link en tekst te wijzigen gebruik je de Systeemconfiguratie-optie **CustomerDashboard::Tiles###FeaturedLink-01**

en	2 - To change the toplevel text please use the System Configuration Option **CustomerDashboard::Configuration::Text**
nl	2 - Om de bovenste tekst te wijzigen, gebruik de Systeemconfiguratie Optie **CustomerDashboard::Configuration::Text**

en	Please disable the config options from not needed tiles.
nl	Schakel de configuratieopties uit van tegels die niet nodig zijn.

en	Documentation History
nl	Documentatiegeschiedenis

en	2019 - OTRS Installation Guide - OTRS AG (https://otrs.com)
nl	2019 - OTRS Installatiehandleiding - OTRS AG (https://otrs.com)

en	2020 - OTOBO Installation Tutorial - Rother OSS GmbH (https://otobo.de)
nl	2020 - OTOBO Installatie Tutorial - Rother OSS GmbH (https://otobo.de)

en	Published by: Rother OSS GmbH, (https://otobo.de), Oberwalting 31, 94339 Leiblfing, Germany. Authors: OTRS AG (original version), Rother OSS GmbH (https://otobo.de)
nl	Gepubliceerd door: Rother OSS GmbH, (https://otobo.de), Oberwalting 31, 94339 Leiblfing, Duitsland. Auteurs: OTRS AG (originele versie), Rother OSS GmbH (https://otobo.de)

en	Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license can be found on the `GNU website <https://www.gnu.org/licenses/fdl-1.3.txt>`__.
nl	Toestemming wordt verleend om dit document te kopiëren, te verspreiden en/of te wijzigen onder de voorwaarden van de GNU Free Documentation License, Versie 1.3 of elke latere versie gepubliceerd door de Free Software Foundation; zonder Onveranderlijke Secties, zonder Teksten op de Voorpagina en zonder Teksten op de Achterpagina. Een kopie van de licentie is te vinden op de `GNU-website <https://www.gnu.org/licenses/fdl-1.3.txt>`__.

en	OTOBO Installation Tutorial
nl	OTOBO Installatiehandleiding

en	This work is copyrighted by OTRS AG (https://otrs.com), Zimmersmühlenweg 11, 61440 Oberursel, Germany.
nl	Dit werk is auteursrechtelijk beschermd door OTRS AG (https://otrs.com), Zimmersmühlenweg 11, 61440 Oberursel, Duitsland.

en	Copyright © for modifications and amendments 2019-2022 ROTHER OSS GmbH (https://otobo.io), Oberwalting 31, 94339 Leiblfing, Germany
nl	Auteursrecht © voor wijzigingen en aanpassingen 2019-2022 ROTHER OSS GmbH (https://otobo.de), Oberwalting 31, 94339 Leiblfing, Duitsland

en	Terms and Conditions OTRS: Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license can be found on the GNU website.
nl	Algemene Voorwaarden OTRS: Toestemming wordt verleend om dit document te kopiëren, te verspreiden en/of te wijzigen onder de voorwaarden van de GNU Free Documentation License, Versie 1.3 of elke latere versie gepubliceerd door de Free Software Foundation; zonder Onveranderlijke Secties, zonder Teksten op de Voorpagina en zonder Teksten op de Achterpagina. Een kopie van de licentie is te vinden op de GNU-website.

en	Terms and Conditions Rother OSS: Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "COPYING".
nl	Algemene voorwaarden Rother OSS: Toestemming wordt verleend om dit document te kopiëren, te verspreiden en/of te wijzigen onder de voorwaarden van de GNU Free Documentation License, Versie 1.3 of elke latere versie gepubliceerd door de Free Software Foundation; zonder Onveranderlijke Secties, zonder Voorbladteksten en zonder Achterbladteksten. Een kopie van de licentie is opgenomen in de sectie "COPYING".

en	Published by: Rother OSS GmbH, (https://otobo.io), Oberwalting 31, 94339 Leiblfing, Germany.
nl	Gepubliceerd door: Rother OSS GmbH, (https://otobo.de), Oberwalting 31, 94339 Leiblfing, Duitsland.

en	Authors: OTRS AG (original version), Rother OSS GmbH (https://otobo.io).
nl	Auteurs: OTRS AG (originele versie), Rother OSS GmbH (https://otobo.de).

en	Contents
nl	Inhoud

en	OTOBO Installation
nl	OTOBO Installatie

en	This chapter describes the installation and basic configuration of the central OTOBO framework.
nl	Dit hoofdstuk beschrijft de installatie en basisconfiguratie van het centrale OTOBO-framework.

en	Follow the detailed steps in this chapter to install OTOBO on your server. You can then use its web interface to login and administer the system.
nl	Volg de gedetailleerde stappen in dit hoofdstuk om OTOBO op je server te installeren. Je kunt daarna de webinterface gebruiken om in te loggen en het systeem te beheren.

en	We recommend Docker and Docker Compose for the OTOBO installation. By using the provided Docker images, all recommended dependencies (such as Elasticsearch, Redis Cache, etc.) are installed and configured automatically. Updates are thus greatly simplified and the performance has been improved. You can find the instructions for Docker-based installation at https://doc.otobo.org/manual/installation/11.0/en/content/installation-docker.html .
nl	Wij raden Docker en Docker Compose aan voor de installatie van OTOBO. Door gebruik te maken van de meegeleverde Docker images, worden alle aanbevolen afhankelijkheden (zoals Elasticsearch, Redis Cache, etc.) automatisch geïnstalleerd en geconfigureerd. Updates zijn hierdoor sterk vereenvoudigd en de performance is verbeterd. Je kunt de instructies voor een Docker-gebaseerde installatie vinden op https://doc.otobo.org/manual/installation/11.0/en/content/installation-docker.html .

en	Preparation: Disable SELinux when it is installed and enabled
nl	Voorbereiding: Schakel SELinux uit als het geïnstalleerd en ingeschakeld is

en	If your system uses SELinux, you should disable it, otherwise OTOBO will not work correctly.
nl	Als je systeem SELinux gebruikt, moet je het uitschakelen, anders werkt OTOBO niet correct.

en	Try the command ``sestatus`` and ``getenforce`` when you are not sure whether SELinux is installed and enabled on your system.
nl	Probeer de commando's ``sestatus`` en ``getenforce`` als je niet zeker weet of SELinux is geïnstalleerd en ingeschakeld op je systeem.

en	The ``sestatus`` command returns the SELinux status and the SELinux policy being used. SELinux status: enabled is returned when SELinux is enabled. Current mode: enforcing is returned when SELinux is running in enforcing mode. Policy from config file: targeted is returned when the SELinux targeted policy is used.
nl	Het commando ``sestatus`` geeft de SELinux-status en het gebruikte SELinux-beleid terug. SELinux-status: ingeschakeld wordt teruggegeven wanneer SELinux is ingeschakeld. Huidige modus: handhavend wordt teruggegeven wanneer SELinux in handhavingsmodus draait. Beleid uit configuratiebestand: gericht wordt teruggegeven wanneer het gerichte SELinux-beleid wordt gebruikt.

en	Here's how to disable SELinux for RHEL/CentOS/Fedora.
nl	Hier lees je hoe je SELinux uitschakelt voor RHEL/CentOS/Fedora.

en	Configure ``SELINUX=disabled`` in the ``/etc/selinux/config`` file:
nl	Configureer ``SELINUX=disabled`` in het bestand ``/etc/selinux/config``:

en	Reboot your system. After reboot, confirm that the ``getenforce`` command returns *Disabled*:
nl	Herstart je systeem. Na de herstart, bevestig dat het commando ``getenforce`` *Disabled* teruggeeft:

en	Step 1: Unpack and Install OTOBO
nl	Stap 1: Pak OTOBO uit en installeer het

en	Download the latest otobo release from https://ftp.otobo.org/pub/otobo/. Unpack the source archive (for example, using ``tar``) into the directory ``/opt/otobo-install``:
nl	Download de laatste otobo-release van https://ftp.otobo.org/pub/otobo/. Pak het bronarchief uit (bijvoorbeeld met ``tar``) in de map ``/opt/otobo-install``:

en	Step 2: Install Additional Programs and Perl Modules
nl	Stap 2: Installeer extra programma's en Perl-modules

en	Use the following script to get an overview of all installed and required CPAN modules and other external dependencies.
nl	Gebruik het volgende script om een overzicht te krijgen van alle geïnstalleerde en vereiste CPAN-modules en andere externe afhankelijkheden.

en	On Debian systems you may need to manually install some perl packages:
nl	Op Debian-systemen moet je mogelijk handmatig enkele Perl-pakketten installeren:

en	Please note that OTOBO requires a working Perl installation with all *core* modules such as the module ``version``. These modules are not explicitly checked by the script. You may need to install a ``perl-core`` package on some systems like RHEL that do not install the Perl core packages by default.
nl	Let op dat OTOBO een werkende Perl-installatie vereist met alle *kern*-modules zoals de module ``version``. Deze modules worden niet expliciet gecontroleerd door het script. Op sommige systemen zoals RHEL, die standaard de Perl-kernpakketten niet installeren, moet je mogelijk een ``perl-core`` pakket installeren.

en	To install the required and optional packages, you can use either CPAN or the package manager of your Linux distribution.
nl	Om de vereiste en optionele pakketten te installeren, kun je zowel CPAN als de pakketbeheerder van je Linux-distributie gebruiken.

en	Execute this command to get an install command to install the missing dependencies:
nl	Voer dit commando uit om een installatiecommando te krijgen om de ontbrekende afhankelijkheden te installeren:

en	There are a number of optional or alternative modules which can be installed, mostly for more customized versions of OTOBO. Calling CheckModules.pl without any argument will list its full functionality.
nl	Er zijn een aantal optionele of alternatieve modules die geïnstalleerd kunnen worden, meestal voor meer aangepaste versies van OTOBO. Het uitvoeren van CheckModules.pl zonder enig argument zal de volledige functionaliteit weergeven.

en	Step 3: Create the OTOBO User
nl	Stap 3: Maak de OTOBO-gebruiker aan

en	Create a dedicated user for OTOBO within its own group:
nl	Maak een speciale gebruiker voor OTOBO binnen zijn eigen groep:

en	Add the user to web server group (if the web server is not running as otobo user):
nl	Voeg de gebruiker toe aan de webservergroep (als de webserver niet draait als otobo-gebruiker):

en	Step 4: Activate the Default Configuration File
nl	Stap 4: Activeer het standaard configuratiebestand

en	There is an OTOBO configuration file bundled in ``$OTOBO_HOME/Kernel/Config.pm.dist``. You must activate it by copying it without the ``.dist`` file name extension.
nl	Er is een OTOBO-configuratiebestand meegeleverd in ``$OTOBO_HOME/Kernel/Config.pm.dist``. Je moet het activeren door het te kopiëren zonder de bestandsextensie ``.dist``.

en	Step 5: Configure the Apache Web Server
nl	Stap 5: Configureer de Apache Webserver

en	First of all, you should install the Apache2 web server and mod_perl; you'd typically do this from your system's package manager. Below you'll find the commands needed to set up Apache on the most popular Linux distributions.
nl	Allereerst moet je de Apache2-webserver en mod_perl installeren; dit doe je doorgaans via de pakketbeheerder van je systeem. Hieronder vind je de commando's die nodig zijn om Apache op de populairste Linux-distributies in te stellen.

en	A critical setting of the Apache web server is the choice of the multi-processing module. For running OTOBO, the recommended choice is the module **mpm_prefork**. Like other Apache modules the multi-processing module can be managed with the tools a2dismod and a2enmod.
nl	Een kritische instelling van de Apache-webserver is de keuze van de multi-processing module. Voor het draaien van OTOBO is de aanbevolen keuze de module **mpm_prefork**. Net als andere Apache-modules kan de multi-processing module beheerd worden met de tools a2dismod en a2enmod.

en	All is fine whem mpm_prefork already is enabled.
nl	Alles is in orde wanneer mpm_prefork al is ingeschakeld.

en	Disable mpm_event when it is currently active.
nl	Schakel mpm_event uit als het momenteel actief is.

en	Disable mpm_worker in case that MPM is enabled.
nl	Schakel mpm_worker uit in het geval dat MPM is ingeschakeld.

en	Finally activate mpm_prefork.
nl	Activeer ten slotte mpm_prefork.

en	OTOBO requires a few more Apache modules to be active for optimal operation. Again, on most platforms you can make sure they are active via the tool a2enmod.
nl	OTOBO vereist een paar extra Apache-modules om optimaal te functioneren. Ook hier kun je op de meeste platforms zorgen dat ze actief zijn via het hulpprogramma a2enmod.

en	On some platforms not all Apache modules exist and an error is displayed when installing. Do not worry and finish the installation, in most cases the module will not be needed.
nl	Op sommige platforms bestaan niet alle Apache modules en wordt er een foutmelding weergegeven bij het installeren. Maak je geen zorgen en rond de installatie af, in de meeste gevallen zal de module niet nodig zijn.

en	Most Apache installations have a ``conf.d`` directory included. On Linux systems you can usually find this directory under ``/etc/apache`` or ``/etc/apache2``.
nl	De meeste Apache-installaties hebben een ``conf.d``-map inbegrepen. Op Linux-systemen kun je deze map meestal vinden onder ``/etc/apache`` of ``/etc/apache2``.

en	Configure Apache without SSL support
nl	Configureer Apache zonder SSL-ondersteuning

en	Copy the template file ``/opt/otobo/scripts/apache2-httpd.include.conf`` to the apache ``sites-available`` directory. In most cases no further editing of the template is required. Then enable the new configuration.
nl	Kopieer het sjabloonbestand ``/opt/otobo/scripts/apache2-httpd.include.conf`` naar de apache ``sites-available`` map. In de meeste gevallen is verdere bewerking van het sjabloon niet nodig. Schakel daarna de nieuwe configuratie in.

en	Configure Apache **with** SSL support
nl	Configureer Apache **met** SSL-ondersteuning

en	Copy the template files ``/opt/otobo/scripts/apache2-httpd-vhost-80.include.conf`` and ``/opt/otobo/scripts/apache2-httpd-vhost-443.include.conf`` to the apache ``sites-available`` directory.
nl	Kopieer de sjabloonbestanden ``/opt/otobo/scripts/apache2-httpd-vhost-80.include.conf`` en ``/opt/otobo/scripts/apache2-httpd-vhost-443.include.conf`` naar de apache ``sites-available`` directory.

en	Please edit the files and add the required information like SSL certificate storage path. After that, enable the OTOBO Apache configuration:
nl	Bewerk de bestanden en voeg de benodigde informatie toe, zoals het opslagpad van het SSL-certificaat. Schakel daarna de Apache-configuratie van OTOBO in:

en	Now you can restart your web server to load the new configuration settings. On most systems you can use the following command to do so:
nl	Nu kun je je webserver herstarten om de nieuwe configuratie-instellingen te laden. Op de meeste systemen kun je het volgende commando gebruiken om dit te doen:

en	Step 6: Set File Permissions
nl	Stap 6: Bestandsrechten instellen

en	Please execute the following command to set the file and directory permissions for OTOBO. It will try to detect the correct user and group settings needed for your setup.
nl	Voer het volgende commando uit om de bestands- en maprechten voor OTOBO in te stellen. Het zal proberen de juiste gebruikers- en groepsinstellingen te detecteren die nodig zijn voor uw opstelling.

en	Step 7: Setup the Database
nl	Stap 7: Stel de Database in

en	First of all, you should install the database package. It is recommended to use the MySQL or MariaDB package, which will be delivered with your Linux system, but it is possible to use PostgreSQL or Oracle as well.
nl	Allereerst moet je het databasepakket installeren. Het wordt aanbevolen om het MySQL- of MariaDB-pakket te gebruiken, dat wordt meegeleverd met je Linux-systeem, maar het is ook mogelijk om PostgreSQL of Oracle te gebruiken.

en	You'd typically do this from your systems package manager. Below you'll find the commands needed to set up MySQL on the most popular Linux distributions.
nl	Dit doe je doorgaans via de pakketbeheerder van je systeem. Hieronder vind je de commando's die nodig zijn om MySQL in te stellen op de meest populaire Linux-distributies.

en	After installing the MySQL server you need configure it.
nl	Na het installeren van de MySQL-server moet je deze configureren.

en	In MySQL higher or equal version 5.7 a new authentication module is active, and it is not possible to use the OTOBO web installer for database creation. Please login to the mysql console and set a different authentication module and password for the user ``root`` if this is the case:
nl	In MySQL versie 5.7 of hoger is een nieuw authenticatiemodule actief, en het is niet mogelijk om de OTOBO webinstaller te gebruiken voor databasecreatie. Log in op de MySQL-console en stel een andere authenticatiemodule en wachtwoord in voor de gebruiker ``root`` als dit het geval is:

en	For MariaDB > 10.1 use instead the following command:
nl	Gebruik voor MariaDB > 10.1 in plaats daarvan het volgende commando:

en	If this command not work, please try the following commands:
nl	Als dit commando niet werkt, probeer dan de volgende commando's:

en	After OTOBO installation it is possible to change the authentication module again, if needed.
nl	Na de installatie van OTOBO is het mogelijk om het authenticatiemodule opnieuw te wijzigen, indien nodig.

en	The following configuration settings are minimum requirements for MySQL setups. Please add the following lines to the MySQL Server configuration file ``/etc/my.cnf``, ``/etc/mysql/my.cnf`` or ``/etc/mysql/mysql.conf.d/mysqld.cnf`` under the ``[mysqld]`` section:
nl	De volgende configuratie-instellingen zijn minimale vereisten voor MySQL-opstellingen. Voeg de volgende regels toe aan het MySQL Server configuratiebestand ``/etc/my.cnf``, ``/etc/mysql/my.cnf`` of ``/etc/mysql/mysql.conf.d/mysqld.cnf`` onder de sectie ``[mysqld]``:

en	For MySQL prior to MySQL 8.0 the query cache size should also be set:
nl	Voor MySQL vóór MySQL 8.0 moet ook de grootte van de querycache worden ingesteld:

en	Also add the following lines to the MySQL Server configuration file ``/etc/my.cnf``, ``/etc/mysql/my.cnf`` or ``/etc/mysql/mysql.conf.d/mysqldump.cnf`` under the ``[mysqldump]`` section:
nl	Voeg de volgende regels toe aan het configuratiebestand van de MySQL-server ``/etc/my.cnf``, ``/etc/mysql/my.cnf`` of ``/etc/mysql/mysql.conf.d/mysqldump.cnf`` in de sectie ``[mysqldump]``:

en	For production purposes we recommend to use the tool ``mysqltuner`` to find the perfect setup. You can download the script from github ``https://github.com/major/MySQLTuner-perl`` or install it on Debian or Ubuntu systems via package manager:
nl	Voor productiedoeleinden raden we aan om het hulpprogramma ``mysqltuner`` te gebruiken om de perfecte setup te vinden. Je kunt het script downloaden van github ``https://github.com/major/MySQLTuner-perl`` of het installeren op Debian of Ubuntu systemen via de pakketbeheerder:

en	After installing execute the script:
nl	Voer na installatie het script uit:

en	Step 8: Setup Elasticsearch
nl	Stap 8: Stel Elasticsearch in

en	OTOBO recommends an active installation of Elasticsearch for quick search. The easiest way is to setup Elasticsearch on the same host as OTOBO and binding it to its default port.
nl	OTOBO raadt een actieve installatie van Elasticsearch aan voor snelle zoekopdrachten. De eenvoudigste manier is om Elasticsearch op dezelfde host als OTOBO te installeren en het te binden aan de standaardpoort.

en	Elasticsearch installation example based on Ubuntu 18.04 LTS
nl	Voorbeeld van een Elasticsearch-installatie gebaseerd op Ubuntu 18.04 LTS

en	JDK Installation
nl	JDK Installatie

en	Elasticsearch Installation
nl	Installatie van Elasticsearch

en	Elasticsearch Installation on another Linux distribution
nl	Elasticsearch-installatie op een andere Linux-distributie

en	Please follow the installation tutorial found at https://www.elastic.co/guide/en/elasticsearch/reference/current/setup.html.
nl	Volg alstublieft de installatiehandleiding die je kunt vinden op https://www.elastic.co/guide/en/elasticsearch/reference/current/setup.html.

en	Elasticsearch Module Installation
nl	Installatie van Elasticsearch-module

en	Additionally, OTOBO requires plugins to be installed into Elasticsearch:
nl	Daarnaast vereist OTOBO dat plugins worden geïnstalleerd in Elasticsearch:

en	Elasticsearch Configuration
nl	Elasticsearch Configuratie

en	Elasticsearch has a multitude of configuration options and possibilities.
nl	Elasticsearch heeft een veelvoud aan configuratieopties en mogelijkheden.

en	In order to ensure error-free operation, you should adjust the jvm heap space for larger OTOBO systems. Please adjust the settings in the file ``/etc/elasticsearch/jvm.options``. You should always set the min and max JVM heap size to the same value. For example, to set the heap to 4 GB, set:
nl	Om een foutloze werking te garanderen, moet je de jvm heap space voor grotere OTOBO-systemen aanpassen. Pas de instellingen aan in het bestand ``/etc/elasticsearch/jvm.options``. Je moet altijd de min en max JVM heap size op dezelfde waarde instellen. Om bijvoorbeeld de heap in te stellen op 4 GB, stel je in:

en	In our tests, a value between 4 and 10 GB for medium-sized installations has proven to be the best.
nl	In onze tests heeft een waarde tussen 4 en 10 GB voor middelgrote installaties zich als het beste bewezen.

en	See ``https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html`` for more information.
nl	Zie ``https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html`` voor meer informatie.

en	Now you can restart your Elasticsearch server to load the new configuration settings. On most systems you can use the following command to do so:
nl	Nu kun je je Elasticsearch-server opnieuw starten om de nieuwe configuratie-instellingen te laden. Op de meeste systemen kun je het volgende commando gebruiken om dit te doen:

en	Step 9: Basic System Configuration
nl	Stap 9: Basis Systeemconfiguratie

en	Please use the web installer at http://localhost/otobo/installer.pl (replace "localhost" with your OTOBO hostname) to set up your database and basic system settings such as email accounts.
nl	Gebruik alstublieft de webinstaller op http://localhost/otobo/installer.pl (vervang "localhost" door je OTOBO-hostnaam) om je database en basisinstellingen zoals e-mailaccounts in te stellen.

en	Step 10: First Login
nl	Stap 10: Eerste inlog

en	Now you are ready to login to your system at http://localhost/otobo/index.pl as user ``root@localhost`` with the password that was generated (see above).
nl	Je bent nu klaar om in te loggen op je systeem via http://localhost/otobo/index.pl als gebruiker ``root@localhost`` met het wachtwoord dat gegenereerd is (zie hierboven).

en	Step 11: Start the OTOBO Daemon
nl	Stap 11: Start de OTOBO Daemon

en	OTOBO daemon is responsible for handling any asynchronous and recurring tasks in OTOBO. What has been in cron file definitions previously is now handled by the OTOBO daemon, which is required to operate OTOBO. The daemon also handles all GenericAgent jobs and must be started from the OTOBO user.
nl	De OTOBO daemon is verantwoordelijk voor het afhandelen van alle asynchrone en terugkerende taken in OTOBO. Wat voorheen in cron-bestandsdefinities stond, wordt nu afgehandeld door de OTOBO daemon, die nodig is om OTOBO te bedienen. De daemon behandelt ook alle GenericAgent-taken en moet gestart worden vanuit de OTOBO-gebruiker.

en	Step 12: Cron jobs for the OTOBO user
nl	Stap 12: Cronjobs voor de OTOBO-gebruiker

en	There are two default OTOBO cron files in ``/opt/otobo/var/cron/\*.dist``, and their purpose is to make sure that the OTOBO Daemon is running. They need to be be activated by copying them without the ".dist" filename extension.
nl	Er zijn twee standaard OTOBO cron-bestanden in ``/opt/otobo/var/cron/\*.dist``, en hun doel is om ervoor te zorgen dat de OTOBO Daemon draait. Ze moeten geactiveerd worden door ze te kopiëren zonder de ".dist" bestandsextensie.

en	With this step, the basic system setup is finished.
nl	Met deze stap is de basisinstallatie van het systeem voltooid.

en	Step 13: Setup Bash Auto-Completion (optional)
nl	Stap 13: Bash Auto-Completion instellen (optioneel)

en	All regular OTOBO command line operations happen via the OTOBO console interface. This provides an auto-completion for the bash shell which makes finding the right command and options much easier.
nl	Alle reguliere OTOBO command-line operaties gebeuren via de OTOBO console interface. Dit biedt een auto-aanvulling voor de bash shell wat het vinden van het juiste commando en opties veel makkelijker maakt.

en	You can activate the bash auto-completion by installing the package ``bash-completion``. It will automatically detect and load the file ``/opt/otobo/.bash_completion`` for the ``otobo`` user.
nl	Je kunt de bash auto-completion activeren door het pakket ``bash-completion`` te installeren. Het zal automatisch het bestand ``/opt/otobo/.bash_completion`` detecteren en laden voor de gebruiker ``otobo``.

en	After restarting your shell, you can just type this command followed by TAB, and it will list all available commands:
nl	Na het herstarten van je shell, kun je gewoon dit commando typen gevolgd door TAB, en het zal alle beschikbare commando's weergeven:

en	If you type a few characters of the command name, TAB will show all matching commands. After typing a complete command, all possible options and arguments will be shown by pressing TAB.
nl	Als je een paar karakters van de commandonaam typt, zal TAB alle overeenkomende commando's tonen. Nadat je een compleet commando hebt getypt, worden alle mogelijke opties en argumenten getoond door op TAB te drukken.

en	If you have problems, you can execute the following line as user ``otobo`` and add it to your ``~/.bashrc`` to execute the commands from the file.
nl	Als je problemen hebt, kun je de volgende regel als gebruiker ``otobo`` uitvoeren en toevoegen aan je ``~/.bashrc`` om de commando's uit het bestand uit te voeren.

en	Step 14: Further Information
nl	Stap 14: Verdere Informatie

en	We advise you to read the OTOBO :doc:`performance-tuning` chapter.
nl	We adviseren je om het hoofdstuk OTOBO :doc:`performance-tuning` te lezen.

en	Installing using Docker and Docker Compose
nl	Installeren met Docker en Docker Compose

en	With the dockerized OTOBO deployment you can get your personal OTOBO instance up and running within minutes. All of OTOBO´s dependencies are already included in the provided collection of Docker images.
nl	Met de gedockeriseerde OTOBO-implementatie kun je binnen enkele minuten je persoonlijke OTOBO-instantie operationeel hebben. Alle afhankelijkheden van OTOBO zijn al inbegrepen in de aangeboden verzameling Docker-images.

en	Service *db*: MariaDB is set up as the default database.
nl	Service *db*: MariaDB is ingesteld als de standaarddatabase.

en	Service *elastic*: Elasticsearch is set up for the OTOBO power search.
nl	Service *elastic*: Elasticsearch is ingesteld voor de krachtige zoekfunctie van OTOBO.

en	Service *redis*: Redis is enabled for fast caching.
nl	Service *redis*: Redis is ingeschakeld voor snelle caching.

en	Service *web*: Gazelle is used as fast Perl webserver.
nl	Service *web*: Gazelle wordt gebruikt als snelle Perl-webserver.

en	Service *nginx*: Nginx is used as optional reverse proxy for HTTPS support.
nl	Service *nginx*: Nginx wordt gebruikt als optionele reverse proxy voor HTTPS-ondersteuning.

en	We think that this setup is the perfect environment for an OTOBO installation.
nl	We denken dat deze opstelling de perfecte omgeving is voor een OTOBO-installatie.

en	Requirements
nl	Vereisten

en	The minimal versions of required software, that have been tested, are listed here:
nl	De minimale versies van vereiste software, die getest zijn, worden hier vermeld:

en	Docker 19.03.13

en	Docker Compose 1.25.0

en	Git 2.17.1

en	For Ubuntu 24.04 LTS the usage of Compose V2 is recommended.
nl	Voor Ubuntu 24.04 LTS wordt het gebruik van Compose V2 aanbevolen.

en	Compose V2 is implemented as a plugin of the command ``docker``. An alias can be used in order to stay compatible with the ``docker-compose`` command known from Compose V1.
nl	Compose V2 is geïmplementeerd als een plugin van het commando ``docker``. Een alias kan gebruikt worden om compatibel te blijven met het ``docker-compose`` commando bekend van Compose V1.

en	git, Docker, and Docker Compose can be installed with the standard system tools. Here is an example for installation on Ubuntu 20.04 Focal Fossa:
nl	git, Docker en Docker Compose kunnen worden geïnstalleerd met de standaard systeemtools. Hier is een voorbeeld voor installatie op Ubuntu 20.04:

en	Please check the Git and the Docker documentation for instructions on further setup.
nl	Raadpleeg de Git- en Docker-documentatie voor instructies over verdere opstelling.

en	Installation
nl	Installatie

en	The following instructions assume that all requirements are met, that you have a working Docker environment. We assume here that the user **docker_admin** is used for interacting with Docker. The Docker admin may be either the **root** user of the Docker host or a dedicated user with the required permissions.
nl	De volgende instructies gaan ervan uit dat aan alle vereisten is voldaan, dat je een werkende Docker-omgeving hebt. We gaan er hier vanuit dat de gebruiker **docker_admin** wordt gebruikt voor interactie met Docker. De Docker-admin kan ofwel de **root**-gebruiker van de Docker-host zijn of een specifieke gebruiker met de benodigde rechten.

en	1. Clone the otobo-docker repo
nl	1. Kloon de otobo-docker repo

en	The Docker images will eventually be fetched from the repository https://hub.docker.com. But there are some setup and command files that need to be cloned from the *otobo-docker* Github repository. Make sure that you specify the tag that corresponds to the current patch level version of OTOBO. For example, when *OTOBO 11.0.2* is the current version then please use the tag *rel-11_0_2*.
nl	De Docker-images zullen uiteindelijk worden opgehaald uit de repository https://hub.docker.com. Maar er zijn enkele installatie- en commandobestanden die gekloond moeten worden van de *otobo-docker* Github-repository. Zorg ervoor dat je de branch specificeert die overeenkomt met de huidige versie van OTOBO. Bijvoorbeeld, als *OTOBO 10.0.15* de huidige versie is, gebruik dan de branch *rel-10_0*.

en	The location of the cloned repository does not matter. For these instructions we chose */opt/otobo-docker* as the working dir.
nl	De locatie van de gekloonde repository doet er niet toe. Voor deze instructies hebben we */opt/otobo-docker* gekozen als de werkmap.

en	2. Create an initial *.env* file
nl	2. Maak een initiële *.env* bestand

en	The Docker Compose configuration file *.env* is your primary interface for managing your installation of OTOBO. This file must first be created and then be adapted by yourself. In order to simplify the task there are several example files that should be used as starting point. Which sample file it the best fit depends on your use case. In most cases the decision is between *.docker_compose_env_http* and *.docker_compose_env_https*, depending on whether TLS must be supported or not. The other files are for more specialised use cases.
nl	Het Docker Compose configuratiebestand *.env* is uw primaire interface voor het beheren van uw installatie van OTOBO. Dit bestand moet eerst worden aangemaakt en vervolgens door uzelf worden aangepast. Om de taak te vereenvoudigen zijn er verschillende voorbeeldbestanden die als uitgangspunt moeten worden gebruikt. Welk voorbeeldbestand het beste past, hangt af van uw gebruikssituatie. In de meeste gevallen is de keuze tussen *.docker_compose_env_http* en *.docker_compose_env_https*, afhankelijk van of TLS moet worden ondersteund of niet. De andere bestanden zijn voor meer gespecialiseerde gebruikssituaties.

en	.docker_compose_env_http

en	The OTOBO web app provides HTTP.
nl	De OTOBO-webapp biedt HTTP.

en	.docker_compose_env_https

en	The OTOBO web app provides HTTPS by runnning Nginx as a reverse proxy webserver.
nl	De OTOBO-webapp biedt HTTPS door Nginx te draaien als een reverse proxy webserver.

en	.docker_compose_env_https_custom_nginx

en	Like *.docker_compose_env_https* but with support for a custom Nginx configuration.
nl	Net als *.docker_compose_env_https* maar met ondersteuning voor een aangepaste Nginx-configuratie.

en	.docker_compose_env_https_kerberos

en	Like *.docker_compose_env_https* but with sample setup for single sign on. Note that Kerberos support is still **experimental**.
nl	Zoals *.docker_compose_env_https* maar met voorbeeldopstelling voor single sign-on. Let op dat Kerberos-ondersteuning nog steeds **experimenteel** is.

en	.docker_compose_env_http_selenium and .docker_compose_env_https_selenium
nl	.docker_compose_env_http_selenium en .docker_compose_env_https_selenium

en	These are used only for development when Selenium testing is activated.
nl	Deze worden alleen gebruikt voor ontwikkeling wanneer Selenium-testen is geactiveerd.

en	Use ``ls -a`` for listing the hidden sample files.
nl	Gebruik ``ls -a`` om de verborgen voorbeeldbestanden te tonen.

en	Per default OTOBO is served on the standard ports. Port 443 for HTTPS and port 80 for HTTP. When HTTPS is activated then the OTOBO web application actually still runs with HTTP. HTTPS support is achieved by an additional reverse proxy, which is implemented as a nginx service.
nl	Standaard wordt OTOBO op de standaardpoorten aangeboden. Poort 443 voor HTTPS en poort 80 voor HTTP. Wanneer HTTPS is geactiveerd, draait de OTOBO-webapplicatie eigenlijk nog steeds met HTTP. HTTPS-ondersteuning wordt bereikt door een extra reverse proxy, die geïmplementeerd is als een nginx-service.

en	For the following commands we assume that HTTPS should be supported.
nl	Voor de volgende commando's gaan we ervan uit dat HTTPS ondersteund moet worden.

en	3. Configure the password for the database admin user
nl	3. Stel het wachtwoord in voor de databasebeheerder

en	Change the following setting inside your *.env* file:
nl	Wijzig de volgende instelling in je *.env* bestand:

en	``OTOBO_DB_ROOT_PASSWORD=<your_secret_password>``
nl	``OTOBO_DB_ROOT_PASSWORD=<jouw_geheime_wachtwoord>``

en	The password for the database admin user may be chosen freely. The database admin user is needed to create the database user **otobo** and the database schema **otobo**. OTOBO will actually use the dedicated database user **otobo**.
nl	Het wachtwoord voor de databasebeheerder mag vrij gekozen worden. De databasebeheerder is nodig om de databasegebruiker **otobo** en het databaseschema **otobo** aan te maken. OTOBO zal daadwerkelijk de toegewijde databasegebruiker **otobo** gebruiken.

en	4. Set up a volume with SSL configuration for the nginx webproxy (optional)
nl	4. Stel een volume in met SSL-configuratie voor de nginx-webproxy (optioneel)

en	This step can be skipped when OTOBO should be available only via HTTP.
nl	Deze stap kan worden overgeslagen als OTOBO alleen via HTTP beschikbaar moet zijn.

en	nginx needs for SSL encryption a certificate and a private key.
nl	nginx heeft voor SSL-encryptie een certificaat en een privésleutel nodig.

en	For testing and development a self-signed certificate can be used. However for productive use you should work with regular registered certificates.
nl	Voor testen en ontwikkeling kan een zelfondertekend certificaat worden gebruikt. Echter, voor productief gebruik moet je werken met regulier geregistreerde certificaten.

en	See e.g. https://www.digitalocean.com/community/tutorials/how-to-create-a-self-signed-ssl-certificate-for-nginx-in-ubuntu on how to create self-signed certificates.
nl	Zie bijvoorbeeld https://www.digitalocean.com/community/tutorials/how-to-create-a-self-signed-ssl-certificate-for-nginx-in-ubuntu-18-04 voor hoe je zelfondertekende certificaten maakt.

en	To specify a CA chain with a certificate in nginx, it is necessary to copy the CA chain file with the actual certificate into a file.
nl	Om een CA-keten met een certificaat in nginx te specificeren, is het noodzakelijk om het CA-ketenbestand met het daadwerkelijke certificaat in een bestand te kopiëren.

en	The certificate and the private key are stored in a volume, so that they can be used by nginx later on. In any case the volume needs to be generated manually, and we need to copy the certificate and key to the volume:
nl	Het certificaat en de privésleutel worden opgeslagen in een volume, zodat ze later door nginx gebruikt kunnen worden. In elk geval moet het volume handmatig aangemaakt worden, en we moeten het certificaat en de sleutel naar het volume kopiëren:

en	The names of the copied files need to be set in our newly created *.env* file. E.g.
nl	De namen van de gekopieerde bestanden moeten worden ingesteld in ons nieuw aangemaakte *.env*-bestand. Bijv.

en	``OTOBO_NGINX_SSL_CERTIFICATE=/etc/nginx/ssl/ssl-cert.crt`` and ``OTOBO_NGINX_SSL_CERTIFICATE_KEY=/etc/nginx/ssl/ssl-key.key``
nl	``OTOBO_NGINX_SSL_CERTIFICATE=/etc/nginx/ssl/ssl-cert.crt`` en ``OTOBO_NGINX_SSL_CERTIFICATE_KEY=/etc/nginx/ssl/ssl-key.key``

en	Please adapt only the name of the files as the path */etc/nginx/ssl/* is hard coded in the Docker image.
nl	Pas alleen de naam van de bestanden aan, aangezien het pad */etc/nginx/ssl/* hard gecodeerd is in het Docker-beeld.

en	5. Start the Docker containers with Docker Compose
nl	5. Start de Docker containers met Docker Compose

en	Now we start the Docker containers using ``docker-compose``. Per default the Docker images will be fetched from https://hub.docker.com/u/rotheross.
nl	Nu starten we de Docker containers met ``docker-compose``. Standaard worden de Docker images opgehaald van https://hub.docker.com/u/rotheross.

en	To verify that the six required services (five in the case of HTTP only) are actually running, type:
nl	Om te controleren of de zes vereiste diensten (vijf in het geval van alleen HTTP) daadwerkelijk draaien, typ:

en	6. Install and start OTOBO
nl	6. Installeer en start OTOBO

en	Run the OTOBO installer at http://yourIPorFQDN/otobo/installer.pl.
nl	Start de OTOBO-installatie op http://jouwIPofFQDN/otobo/installer.pl.

en	Please configure OTOBO inside the installer with a new MySQL database. As MySQL database root password please use the password you configured in the variable ``OTOBO_DB_ROOT_PASSWORD`` of your *.env* file. Please leave the value ``db`` for the MySQL hostname untouched.
nl	Configureer OTOBO binnen de installer met een nieuwe MySQL-database. Gebruik als MySQL-database rootwachtwoord het wachtwoord dat je hebt ingesteld in de variabele ``OTOBO_DB_ROOT_PASSWORD`` van je *.env*-bestand. Laat de waarde ``db`` voor de MySQL-hostnaam ongewijzigd.

en	**Have fun with OTOBO!**
nl	**Veel plezier met OTOBO!**

en	To change to the OTOBO directory, inside the running container, to work on command line as usual, you can use the following Docker command: ``docker-compose exec web bash``.
nl	Om naar de OTOBO-directory te gaan, binnen de draaiende container, om op de commandoregel te werken zoals gewoonlijk, kun je het volgende Docker-commando gebruiken: ``docker-compose exec web bash``.

en	Additional technical information
nl	Aanvullende technische informatie

en	This section gives some more technical insight into what is happing under the hood.
nl	Dit gedeelte geeft wat meer technisch inzicht in wat er onder de motorkap gebeurt.

en	List of Docker containers
nl	Lijst van Docker-containers

en	Container otobo_web_1

en	OTOBO webserver on internal port 5000.
nl	OTOBO-webserver op interne poort 5000.

en	Container otobo_daemon_1

en	OTOBO daemon. The OTOBO daemon is started and periodically checked.
nl	OTOBO daemon. De OTOBO daemon wordt gestart en periodiek gecontroleerd.

en	Container otobo_db_1

en	Run the database MariaDB on internal port 3306.
nl	Draai de database MariaDB op interne poort 3306.

en	Container otobo_elastic_1

en	Elasticsearch on the internal ports 9200 and 9300.
nl	Elasticsearch op de interne poorten 9200 en 9300.

en	Container otobo_redis_1

en	Run Redis as caching service.
nl	Draai Redis als caching service.

en	Optional container otobo_nginx_1
nl	Optionele container otobo_nginx_1

en	Run nginx as reverse proxy for providing HTTPS support.
nl	Run nginx als reverse proxy om HTTPS-ondersteuning te bieden.

en	Overview over the Docker volumes
nl	Overzicht van de Docker volumes

en	The Docker volumes are created on the host for persistent data. These allow starting and stopping the services without losing data. Keep in mind that containers are temporary and only data in the volumes is permanent.
nl	De Docker-volumes worden op de host gecreëerd voor persistente gegevens. Deze stellen je in staat om de services te starten en te stoppen zonder gegevens te verliezen. Houd er rekening mee dat containers tijdelijk zijn en alleen gegevens in de volumes permanent zijn.

en	otobo_opt_otobo

en	contains */opt/otobo* in the container **web** and **daemon**.
nl	bevat */opt/otobo* in de container **web** en **daemon**.

en	otobo_mariadb_data

en	contains */var/lib/mysql* in the container **db**.
nl	bevat */var/lib/mysql* in de container **db**.

en	otobo_elasticsearch_data

en	contains */usr/share/elasticsearch/datal* in the container **elastic**.
nl	bevat */usr/share/elasticsearch/datal* in de container **elastic**.

en	otobo_redis_data

en	contains data for the container `redis`.
nl	bevat gegevens voor de container `redis`.

en	otobo_nginx_ssl

en	contains the TLS files, certificate and private key, must be initialized manually.
nl	bevat de TLS-bestanden, certificaat en privésleutel, moet handmatig geïnitialiseerd worden.

en	Docker environment variables
nl	Docker omgevingsvariabelen

en	In the instructions we did only minimal configuration. But the file *.env* allows to set more variables. Here is a short list of the most important environment variables. Note that more environment variables are supported by the base images.
nl	In de instructies hebben we slechts een minimale configuratie gedaan. Maar het bestand *.env* maakt het mogelijk om meer variabelen in te stellen. Hier is een korte lijst van de belangrijkste omgevingsvariabelen. Let op dat de basisafbeeldingen meer omgevingsvariabelen ondersteunen.

en	**MariaDB settings**
nl	**MariaDB-instellingen**

en	OTOBO_DB_ROOT_PASSWORD

en	The root password for MariaDB. This setting is required for running the service *db*.
nl	Het root wachtwoord voor MariaDB. Deze instelling is vereist om de service *db* te draaien.

en	**Elasticsearch settings**
nl	**Elasticsearch-instellingen**

en	Elasticsearch needs some settings for productive environments. Please read https://www.elastic.co/guide/en/elasticsearch/reference/7.8/docker.html#docker-prod-prerequisites for detailed information.
nl	Elasticsearch heeft wat instellingen nodig voor productieomgevingen. Lees alsjeblieft https://www.elastic.co/guide/en/elasticsearch/reference/7.8/docker.html#docker-prod-prerequisites voor gedetailleerde informatie.

en	OTOBO_Elasticsearch_ES_JAVA_OPTS

en	Example setting: *OTOBO_Elasticsearch_ES_JAVA_OPTS=-Xms512m -Xmx512m* Please adjust this value for production env to a value up to 4g.
nl	Voorbeeldinstelling: *OTOBO_Elasticsearch_ES_JAVA_OPTS=-Xms512m -Xmx512m* Pas deze waarde voor productieomgevingen aan naar een waarde tot 4g.

en	**Webserver settings**
nl	**Webserverinstellingen**

en	OTOBO_WEB_HTTP_PORT

en	Set in case the HTTP port should deviate from the standard port 80. When HTTPS is enabled, the HTTP port will redirect to HTTPS.
nl	Stel in als de HTTP-poort moet afwijken van de standaardpoort 80. Wanneer HTTPS is ingeschakeld, zal de HTTP-poort doorverwijzen naar HTTPS.

en	**Nginx webproxy settings**
nl	**Nginx webproxy instellingen**

en	These setting are used when HTTPS is enabled.
nl	Deze instellingen worden gebruikt wanneer HTTPS is ingeschakeld.

en	Set in case the HTTP port should deviate from the standard port 80. Will redirect to HTTPS.
nl	Stel in voor het geval de HTTP-poort afwijkt van de standaardpoort 80. Zal doorverwijzen naar HTTPS.

en	OTOBO_WEB_HTTPS_PORT

en	Set in case the HTTPS port should deviate from the standard port 443.
nl	Stel in als de HTTPS-poort moet afwijken van de standaardpoort 443.

en	OTOBO_NGINX_SSL_CERTIFICATE

en	SSL cert for the nginx webproxy. Example: *OTOBO_NGINX_SSL_CERTIFICATE=/etc/nginx/ssl/acme.crt*
nl	SSL-certificaat voor de nginx webproxy. Voorbeeld: *OTOBO_NGINX_SSL_CERTIFICATE=/etc/nginx/ssl/acme.crt*

en	OTOBO_NGINX_SSL_CERTIFICATE_KEY

en	SSL key for the nginx webproxy. Example: *OTOBO_NGINX_SSL_CERTIFICATE_KEY=/etc/nginx/ssl/acme.key*
nl	SSL-sleutel voor de nginx-webproxy. Voorbeeld: *OTOBO_NGINX_SSL_CERTIFICATE_KEY=/etc/nginx/ssl/acme.key*

en	**Nginx webproxy settings for Kerberos**
nl	**Nginx webproxy-instellingen voor Kerberos**

en	This settings are used by Nginx when Kerberos is used for single sign on.
nl	Deze instellingen worden gebruikt door Nginx wanneer Kerberos wordt gebruikt voor single sign-on.

en	OTOBO_NGINX_KERBEROS_KEYTAB

en	Kerberos keytab file. The default is */etc/krb5.keytab*.
nl	Kerberos keytab-bestand. De standaard is */etc/krb5.keytab*.

en	OTOBO_NGINX_KERBEROS_CONFIG

en	Kerberos config file. The default is */etc/krb5.conf*, usually generated from *krb5.conf.template*
nl	Kerberos configuratiebestand. Standaard is dit */etc/krb5.conf*, meestal gegenereerd vanuit *krb5.conf.template*

en	OTOBO_NGINX_KERBEROS_SERVICE_NAME

en	Kerberos Service Name. It is not clear where this setting is actually used anywhere.
nl	Kerberos Service Naam. Het is niet duidelijk waar deze instelling eigenlijk overal voor gebruikt wordt.

en	OTOBO_NGINX_KERBEROS_REALM

en	Kerberos REALM. Used in */etc/krb5.conf*.
nl	Kerberos REALM. Gebruikt in */etc/krb5.conf*.

en	OTOBO_NGINX_KERBEROS_KDC

en	Kerberos kdc / AD Controller. Used in */etc/krb5.conf*.
nl	Kerberos kdc / AD Controller. Gebruikt in */etc/krb5.conf*.

en	OTOBO_NGINX_KERBEROS_ADMIN_SERVER

en	Kerberos Admin Server. Used in */etc/krb5.conf*.
nl	Kerberos Admin Server. Gebruikt in */etc/krb5.conf*.

en	OTOBO_NGINX_KERBEROS_DEFAULT_DOMAIN

en	Kerberos Default Domain. Used in */etc/krb5.conf*.
nl	Kerberos Standaard Domein. Gebruikt in */etc/krb5.conf*.

en	NGINX_ENVSUBST_TEMPLATE_DIR

en	Provide a custom Nginx config template dir. Gives extra flexibility.
nl	Geef een aangepaste Nginx-configuratietemplatesmap op. Biedt extra flexibiliteit.

en	**Docker Compose settings**
nl	**Docker Compose instellingen**

en	These settings are used by Docker Compose directly.
nl	Deze instellingen worden direct gebruikt door Docker Compose.

en	COMPOSE_PROJECT_NAME

en	The project name is used as the prefix for the volumes and containers. Per default this prefix is set to `otobo`, resulting in container names like `otobo_web_1` and `otobo_db_1`. Change this name when you want to run more then one instance of OTOBO on the same server.
nl	De projectnaam wordt gebruikt als voorvoegsel voor de volumes en containers. Standaard is dit voorvoegsel ingesteld op `otobo`, resulterend in containernamen zoals `otobo_web_1` en `otobo_db_1`. Verander deze naam als je meer dan één instantie van OTOBO op dezelfde server wilt draaien.

en	COMPOSE_PATH_SEPARATOR

en	Separator for the value of COMPOSE_FILE
nl	Scheidingsteken voor de waarde van COMPOSE_FILE

en	COMPOSE_FILE

en	Use *docker-compose/otobo-base.yml* as the base and add the wanted extension files. E.g *docker-compose/otobo-override-http.yml* or *docker-compose/otobo-override-https.yml*.
nl	Gebruik *docker-compose/otobo-base.yml* als basis en voeg de gewenste uitbreidingsbestanden toe. Bijv. *docker-compose/otobo-override-http.yml* of *docker-compose/otobo-override-https.yml*.

en	OTOBO_IMAGE_OTOBO, OTOBO_IMAGE_OTOBO_ELASTICSEARCH, OTOBO_IMAGE_OTOBO_NGINX, ...

en	Used for specifying alternative Docker images. Useful for testing local builds or for using updated versions of the images.
nl	Gebruikt voor het specificeren van alternatieve Docker-afbeeldingen. Handig voor het testen van lokale builds of voor het gebruiken van bijgewerkte versies van de afbeeldingen.

en	Advanced topics
nl	Geavanceerde onderwerpen

en	Custom configuration of the nginx webproxy
nl	Aangepaste configuratie van de nginx-webproxy

en	The container ``otobo_nginx_1`` provides HTTPS support by running Nginx as a reverse proxy. The Docker image that runs in the container is composed of the official Nginx Docker image, https://hub.docker.com/_/nginx, along with a OTOBO specific configuration of Nginx.
nl	De container ``otobo_nginx_1`` biedt HTTPS-ondersteuning door Nginx als een reverse proxy te draaien. Het Docker-image dat in de container draait, bestaat uit het officiële Nginx Docker-image, https://hub.docker.com/_/nginx, samen met een specifieke OTOBO-configuratie van Nginx.

en	The default OTOBO specific configuration can be found within the Docker image at */etc/nginx/template/otobo_nginx.conf.template*. Actually, this is only a template for the final configuration. There is a process, provided by the Nginx base image, that replaces the macros in the template with the corresponding environment variable. This process runs when the container starts up. In the default template file, the following macros are used:
nl	De standaard OTOBO-specifieke configuratie kan gevonden worden binnen het Docker-image op */etc/nginx/template/otobo_nginx.conf.template*. Eigenlijk is dit slechts een sjabloon voor de uiteindelijke configuratie. Er is een proces, verzorgd door het Nginx basisimage, dat de macro's in het sjabloon vervangt met de overeenkomstige omgevingsvariabelen. Dit proces wordt uitgevoerd wanneer de container opstart. In het standaard sjabloonbestand worden de volgende macro's gebruikt:

en	For configuring SSL.
nl	Voor het configureren van SSL.

en	OTOBO_NGINX_WEB_HOST

en	The internally used HTTP host.
nl	De intern gebruikte HTTP-host.

en	OTOBO_NGINX_WEB_PORT

en	The internally used HTTP port.
nl	De intern gebruikte HTTP-poort.

en	See step `4.` for how this configuration possibility was used for setting up the SSL certificate.
nl	Zie stap `4.` voor hoe deze configuratiemogelijkheid werd gebruikt voor het instellen van het SSL-certificaat.

en	When the standard macros are not sufficient, then the customisation can go further. This can be achieved by replacing the default config template with a customized version. It is best practice to not simple change the configuration in the running container. Instead we first create a persistent volume that contains the custom config. Then we tell the *otobo_nginx_1* to mount the new volume and to use the customized configuration.
nl	Wanneer de standaard macro's niet voldoende zijn, kan de aanpassing verder gaan. Dit kan worden bereikt door het standaardconfiguratiesjabloon te vervangen door een aangepaste versie. Het is het beste om de configuratie in de draaiende container niet zomaar te wijzigen. In plaats daarvan maken we eerst een persistent volume dat de aangepaste configuratie bevat. Vervolgens vertellen we de *otobo_nginx_1* om het nieuwe volume te koppelen en de aangepaste configuratie te gebruiken.

en	First comes generation of the new volume. In these sample commands, we use the existing template as a starting point.
nl	Eerst wordt het nieuwe volume gegenereerd. In deze voorbeeldcommando's gebruiken we de bestaande sjabloon als uitgangspunt.

en	After setting up the volume, the adapted configuration must be activated. The new volume is set up in *docker-compose/otobo-nginx-custom-config.yml*. Therefore this file must be added to **COMPOSE_FILE**. Then Nginx must be directed to use the new config. This is done by setting **NGINX_ENVSUBST_TEMPLATE_DIR** in the environment. In order to achieve this, uncomment or add the following lines in your *.env* file:
nl	Nadat je het volume hebt ingesteld, moet de aangepaste configuratie geactiveerd worden. Het nieuwe volume wordt ingesteld in *docker-compose/otobo-nginx-custom-config.yml*. Daarom moet dit bestand toegevoegd worden aan **COMPOSE_FILE**. Vervolgens moet Nginx geïnstrueerd worden om de nieuwe configuratie te gebruiken. Dit doe je door **NGINX_ENVSUBST_TEMPLATE_DIR** in de omgeving in te stellen. Om dit te bereiken, commentarieer je de volgende regels uit of voeg je ze toe aan je *.env* bestand:

en	The changed Docker Compose configuration can be inspected with:
nl	De gewijzigde Docker Compose-configuratie kan worden geïnspecteerd met:

en	Finally, the containers can be started again:
nl	Tot slot kunnen de containers weer gestart worden:

en	See also the section "Using environment variables in nginx configuration (new in 1.19)" in https://hub.docker.com/_/nginx.
nl	Zie ook de sectie "Gebruik van omgevingsvariabelen in nginx-configuratie (nieuw in 1.19)" op https://hub.docker.com/_/nginx.

en	Single Sign On Using the Kerberos Support in Nginx
nl	Single Sign On met Kerberos-ondersteuning in Nginx

en	**Short Description**
nl	**Korte beschrijving**

en	For enabling authentication with Kerberos please base you *.env file* on the sample file *.docker_compose_env_https_kerberos*. This activates the special configuration in *docker-compose/otobo-override-https-kerberos.yml*. This Docker compose configuration file selects a Nginx image that supports Kerberos. It also passes some Kerberos specific settings as environment values to the running Nginx container. These settings are listed above.
nl	Om authenticatie met Kerberos mogelijk te maken, baseer je je *.env-bestand* op het voorbeeldbestand *.docker_compose_env_https_kerberos*. Dit activeert de speciale configuratie in *docker-compose/otobo-override-https-kerberos.yml*. Dit Docker compose-configuratiebestand selecteert een Nginx-image dat Kerberos ondersteunt. Het geeft ook enkele Kerberos-specifieke instellingen door als omgevingswaarden aan de draaiende Nginx-container. Deze instellingen staan hierboven vermeld.

en	As usual, the values for these setting can be specified in the *.env* file. Most of ghese setting will be used as replacement values for the template https://github.com/RotherOSS/otobo/blob/rel-11_0/scripts/nginx/kerberos/templates/krb5.conf.template . The replacement takes place during the startup of the container. In the running container the adapted config will be available in */etc/krb5.conf*.
nl	Zoals gewoonlijk kunnen de waarden voor deze instellingen worden opgegeven in het *.env*-bestand. De meeste van deze instellingen worden gebruikt als vervangingswaarden voor de sjabloon https://github.com/RotherOSS/otobo/blob/rel-10_1/scripts/nginx/kerberos/templates/krb5.conf.template. De vervanging vindt plaats tijdens het opstarten van de container. In de draaiende container is de aangepaste configuratie beschikbaar in */etc/krb5.conf*.

en	Providing an user specific */etc/krb5.conf* file is still possible. This can be done by mounting a volume that overrides */etc/krb5.conf* in the container. This can be achieved by setting OTOBO_NGINX_KERBEROS_CONFIG in the *.env* file and by activating the mount directove in *docker-compose/otobo-override-https-kerberos.yml*.
nl	Het is nog steeds mogelijk om een gebruikersspecifiek */etc/krb5.conf*-bestand te voorzien. Dit kan gedaan worden door een volume te koppelen dat */etc/krb5.conf* in de container overschrijft. Dit kan bereikt worden door OTOBO_NGINX_KERBEROS_CONFIG in te stellen in het *.env*-bestand en door de koppelingsdirectief in *docker-compose/otobo-override-https-kerberos.yml* te activeren.

en	*/etc/krb5.keytab* is always installation specific and must therefore always be mounted from the host system.
nl	*/etc/krb5.keytab* is altijd specifiek voor de installatie en moet daarom altijd van het hostsysteem worden gemount.

en	**Kerberos SSO Installation Tutorial**
nl	**Installatiehandleiding Kerberos SSO**

en	:doc:`sso-kerberos`

en	Choosing non-standard ports
nl	Niet-standaard poorten kiezen

en	Per default the ports 443 and 80 serve HTTPS and HTTP respectively. There can be cases where one or both of these ports are already used by other services. In these cases the default ports can be overridden by specifying `OTOBO_WEB_HTTP_PORT` and `OTOBO_WEB_HTTPS_PORT` in the *.env* file.
nl	Standaard bedienen de poorten 443 en 80 respectievelijk HTTPS en HTTP. Er kunnen gevallen zijn waarin een of beide van deze poorten al worden gebruikt door andere diensten. In deze gevallen kunnen de standaardpoorten worden overschreven door `OTOBO_WEB_HTTP_PORT` en `OTOBO_WEB_HTTPS_PORT` te specificeren in het *.env*-bestand.

en	Skip startup of specific services
nl	Opstarten van specifieke services overslaan

en	The current Docker compose setup start five, six when HTTPS is activated, services. But there are valid use cases where one or more of these services are not needed. The prime example is when the database should not run as a Docker service, but as an external database. Unfortunately there is no dedicated Docker compose option for skipping specific services. But the option `--scale` can be abused for this purpose. So for an installation with an external database the following command can be used:
nl	De huidige Docker compose setup start vijf, zes wanneer HTTPS is geactiveerd, services. Maar er zijn geldige gebruiksscenario's waarbij een of meer van deze services niet nodig zijn. Het voornaamste voorbeeld is wanneer de database niet als een Docker-service moet draaien, maar als een externe database. Helaas is er geen specifieke Docker compose optie om bepaalde services over te slaan. Maar de optie `--scale` kan hiervoor misbruikt worden. Dus voor een installatie met een externe database kan het volgende commando worden gebruikt:

en	Of course the same goal can also be achieved by editing the file *docker-compose/otobo-base.yml* and removing the relevant service definitions.
nl	Natuurlijk kan hetzelfde doel ook bereikt worden door het bestand *docker-compose/otobo-base.yml* te bewerken en de relevante service-definities te verwijderen.

en	Prepare offline installation
nl	Bereid offline installatie voor

en	Please download `the latest version of otobo-docker <https://doc.otobo.org/manual/installation/11.0/en/content/installation-docker.html#clone-the-otobo-docker-repo>`__ on a system that has internet access and where docker is installed. Then navigate to the following folder *otobo-docker/docker-compose*.
nl	Download alsjeblieft `de laatste versie van otobo-docker <https://doc.otobo.org/manual/installation/10.1/en/content/installation-docker.html#clone-the-otobo-docker-repo>`__ op een systeem met internettoegang en waar docker geïnstalleerd is. Navigeer dan naar de volgende map *otobo-docker/docker-compose*.

en	Now you can run the following command to download all Docker images from a specific file, in my example I use the *otobo-base.yml*.
nl	Nu kun je het volgende commando uitvoeren om alle Docker-images uit een specifiek bestand te downloaden, in mijn voorbeeld gebruik ik *otobo-base.yml*.

en	After that, the images (.docker) are located in the docker-compose folder and can be uploaded to the target system via e.g `SCP <https://en.wikipedia.org/wiki/Secure_copy_protocol>`__.
nl	Daarna bevinden de afbeeldingen (.docker) zich in de docker-compose map en kunnen ze via bijvoorbeeld `SCP <https://en.wikipedia.org/wiki/Secure_copy_protocol>`__ naar het doelsysteem worden geüpload.

en	On the offline target system, go to the folder where the docker images are stored. And enter the following command to import them one by one.
nl	Ga op het offline doelsysteem naar de map waar de docker-afbeeldingen zijn opgeslagen. En voer het volgende commando in om ze één voor één te importeren.

en	In the following example I import the mariadb image:
nl	In het volgende voorbeeld importeer ik het mariadb-beeld:

en	Customizing OTOBO Docker Compose
nl	OTOBODocker Compose Aanpassen

en	Instead of editing the files under *docker-compose/* and risking to overwrite your own options with the `next update <https://doc.otobo.org/manual/installation/11.0/en/content/updating-docker.html#updating-the-docker-compose-files>`_ of the otobo-docker folder, it is advisable to create an extra YAML file where the specific services are overwritten with additional options.
nl	In plaats van de bestanden onder *docker-compose/* te bewerken en het risico te lopen je eigen opties te overschrijven met de `volgende update <https://doc.otobo.org/manual/installation/10.1/nl/content/updating-docker.html#updating-the-docker-compose-files>`_ van de otobo-docker map, is het aan te raden om een extra YAML-bestand te maken waar de specifieke services worden overschreven met extra opties.

en	A common example would be to make the database container accessible from the outside via port 3306. For this you could create an extra docker compose file thats look like:
nl	Een veelvoorkomend voorbeeld zou zijn om de databasecontainer toegankelijk te maken van buitenaf via poort 3306. Hiervoor zou je een extra docker compose-bestand kunnen maken dat er zo uitziet:

en	Now we have to tell *docker-compose* to include our new file. For this you have to add your YAML file to the *COMPOSE_FILE* variable in the *.env* file, for example:
nl	Nu moeten we *docker-compose* vertellen om ons nieuwe bestand te includeren. Hiervoor moet je je YAML-bestand toevoegen aan de *COMPOSE_FILE* variabele in het *.env* bestand, bijvoorbeeld:

en	Now we can use *docker-compose* to recreate our container
nl	Nu kunnen we *docker-compose* gebruiken om onze container opnieuw te maken

en	With this procedure you can customize any service or volumes.
nl	Met deze procedure kun je elke service of volumes aanpassen.

en	Customizing the OTOBO Docker image
nl	Het OTOBO Docker-image aanpassen

en	Many customizations can be done in the external volume *otobo_opt_otobo* which corresponds to the directory */opt/otobo* in the Docker image. This works e.g. for local Perl modules which can be installed into */opt/otobo/local*. Here is an example that installs the not very useful CPAN module `Acme::123`.
nl	Veel aanpassingen kunnen worden gedaan in het externe volume *otobo_opt_otobo* dat overeenkomt met de map */opt/otobo* in het Docker-image. Dit werkt bijvoorbeeld voor lokale Perl-modules die geïnstalleerd kunnen worden in */opt/otobo/local*. Hier is een voorbeeld dat de niet erg nuttige CPAN-module `Acme::123` installeert.

en	The nice thing of this approach is that the Docker image itself does not have to be modified.
nl	Het mooie van deze aanpak is dat de Docker-image zelf niet aangepast hoeft te worden.

en	Installing extra Debian packages is a little bit trickier. One approach is to create a custom *Dockerfile* and use the OTOBO image as the base image. Another approach is to create a modified image directly from a running container. This can be done with the command `docker commit`, https://docs.docker.com/engine/reference/commandline/commit/. A nice writeup of that process is available at https://phoenixnap.com/kb/how-to-commit-changes-to-docker-image.
nl	Het installeren van extra Debian-pakketten is iets ingewikkelder. Een aanpak is om een aangepast *Dockerfile* te maken en de OTOBO-afbeelding als basisafbeelding te gebruiken. Een andere aanpak is om direct vanuit een draaiende container een aangepaste afbeelding te maken. Dit kan met het commando `docker commit`, https://docs.docker.com/engine/reference/commandline/commit/. Een goede uitleg van dat proces is beschikbaar op https://phoenixnap.com/kb/how-to-commit-changes-to-docker-image.

en	But for the latter approach there are two hurdles to overcome. First, the image *otobo* runs per default as the user *otobo* with the UID 1000. The problem is that the user *otobo* is not allowed to install system packages. Thus, the first part of the solution is to pass the option `--user root` when running the image. However the second hurdle is that the default entrypoint script */opt/otobo_install/entrypoint.sh* exits immediately when it is called as *root*. The reasoning behind that design decision is that running inadvertently as *root* should be discouraged. So, the second part of the solution is to specify a different entrypoint script that does not care who the caller is. This leaves us with following example commands, where we add fortune cookies to otobo:
nl	Maar voor de laatste aanpak zijn er twee hindernissen te overwinnen. Ten eerste, het beeld *otobo* draait standaard als de gebruiker *otobo* met de UID 1000. Het probleem is dat de gebruiker *otobo* geen systeempakketten mag installeren. Dus het eerste deel van de oplossing is om de optie `--user root` door te geven bij het draaien van het beeld. Echter, de tweede hindernis is dat het standaard entrypoint script */opt/otobo_install/entrypoint.sh* onmiddellijk afsluit wanneer het als *root* wordt aangeroepen. De redenering achter die ontwerpbeslissing is dat onbedoeld draaien als *root* ontmoedigd moet worden. Dus het tweede deel van de oplossing is om een ander entrypoint script te specificeren dat niet uitmaakt wie de beller is. Dit laat ons met de volgende voorbeeldcommando's, waar we fortune cookies toevoegen aan otobo:

en	Pull a tagged OTOBO image, if we don't have it yet, and check whether the image already provides fortune cookies:
nl	Haal een getagd OTOBO-image op, als we die nog niet hebben, en controleer of het image al fortune cookies biedt:

en	Add fortune cookies to a named container running the original OTOBO image. This is done in an interactive session as the user *root*:
nl	Voeg fortune cookies toe aan een genoemde container die het originele OTOBO beeld draait. Dit wordt gedaan in een interactieve sessie als de gebruiker *root*:

en	Create an image from the stopped container and give it a name. Take into account that the default user and entrypoint script must be restored:
nl	Maak een afbeelding van de gestopte container en geef het een naam. Houd er rekening mee dat de standaardgebruiker en het entrypoint script moeten worden hersteld:

en	Finally we can doublecheck:
nl	Tot slot kunnen we dubbelchecken:

en	The modified image can be specified in your *.env* file and then be used for fun and profit.
nl	De aangepaste afbeelding kan worden gespecificeerd in je *.env*-bestand en vervolgens worden gebruikt voor plezier en winst.

en	Building local images
nl	Lokale afbeeldingen bouwen

en	Building Docker images locally is usually only needed during development. Other use cases are when more current base images should be used for an installation or when extra functionality must be added to the images.
nl	Het lokaal bouwen van Docker-afbeeldingen is meestal alleen nodig tijdens ontwikkeling. Andere gebruiksscenario's zijn wanneer actuelere basisafbeeldingen gebruikt moeten worden voor een installatie of wanneer extra functionaliteit aan de afbeeldingen moet worden toegevoegd.

en	The Docker files needed for creating Docker images locally are part of the the git repository https://github.com/RotherOSS/otobo:
nl	De Docker-bestanden die nodig zijn voor het lokaal aanmaken van Docker-afbeeldingen zijn onderdeel van de git-repository https://github.com/RotherOSS/otobo:

en	*otobo.web.dockerfile*

en	*otobo.nginx.dockerfile*

en	*otobo.elasticsearch.dockerfile*

en	The script for the actual creation of the images is *bin/docker/build_docker_images.sh*.
nl	Het script voor het daadwerkelijk maken van de afbeeldingen is *bin/docker/build_docker_images.sh*.

en	The locally built Docker images are tagged as ``local-<OTOBO_VERSION>`` using the version set up the file *RELEASE*.
nl	De lokaal gebouwde Docker-afbeeldingen worden getagd als ``local-<OTOBO_VERSION>`` met de versie ingesteld in het bestand *RELEASE*.

en	After building the local images, one can return to the *docker-compose* directory. The local images are declared by setting ``OTOBO_IMAGE_OTOBO``, ``OTOBO_IMAGE_OTOBO_ELASTICSEARCH``, ``OTOBO_IMAGE_OTOBO_NGINX`` in *.env*.
nl	Na het bouwen van de lokale afbeeldingen, kan men terugkeren naar de *docker-compose* map. De lokale afbeeldingen worden verklaard door ``OTOBO_IMAGE_OTOBO``, ``OTOBO_IMAGE_OTOBO_ELASTICSEARCH``, ``OTOBO_IMAGE_OTOBO_NGINX`` in *.env* in te stellen.

en	Automatic Installation
nl	Automatische Installatie

en	Instead of going through http://yourIPorFQDN/otobo/installer.pl, one can take a short cut. This is useful for running the test suite on a fresh installation.
nl	In plaats van door http://yourIPorFQDN/otobo/installer.pl te gaan, kan men een kortere weg nemen. Dit is handig voor het uitvoeren van de testsuite op een nieuwe installatie.

en	``docker-compose down -v`` will remove all previous setup and data.
nl	``docker-compose down -v`` zal alle vorige instellingen en gegevens verwijderen.

en	List of useful commands
nl	Lijst van nuttige commando's

en	**Docker**

en	``docker system prune -a`` system clean-up (removes all unused images, containers, volumes, networks)
nl	``docker system prune -a`` systeemopruiming (verwijdert alle ongebruikte afbeeldingen, containers, volumes, netwerken)

en	``docker version`` show version
nl	``docker version`` toon versie

en	``docker build --tag otobo --file=otobo.web.Dockerfile .`` build an image
nl	``docker build --tag otobo --file=otobo.web.Dockerfile .`` bouw een image

en	``docker run --publish 80:5000 otobo`` run the new image
nl	``docker run --publish 80:5000 otobo`` start de nieuwe afbeelding

en	``docker run -it -v opt_otobo:/opt/otobo otobo bash`` log into the new image
nl	``docker run -it -v opt_otobo:/opt/otobo otobo bash`` inloggen op het nieuwe image

en	``docker run -it -v opt_otobo:/opt/otobo --entrypoint bash otobo`` try that in case entrypoint.sh is broken
nl	``docker run -it -v opt_otobo:/opt/otobo --entrypoint bash otobo`` probeer dat als entrypoint.sh kapot is

en	``docker ps`` show running images
nl	``docker ps`` toont draaiende images

en	``docker images`` show available images
nl	``docker images`` toont beschikbare afbeeldingen

en	``docker volume ls`` list volumes
nl	``docker volume ls`` lijst volumes

en	``docker volume inspect otobo_opt_otobo`` inspect a volume
nl	``docker volume inspect otobo_opt_otobo`` inspecteert een volume

en	``docker volume inspect --format '{{ .Mountpoint }}' otobo_nginx_ssl`` get volume mountpoint
nl	``docker volume inspect --format '{{ .Mountpoint }}' otobo_nginx_ssl`` krijg volume mountpoint

en	``docker volume rm tmp_volume`` remove a volume
nl	``docker volume rm tmp_volume`` verwijder een volume

en	``docker inspect <container>`` inspect a container
nl	``docker inspect <container>`` inspecteer een container

en	``docker save --output otobo.tar otobo:latest-11_0 && tar -tvf otobo.tar`` list files in an image
nl	``docker save --output otobo.tar otobo:latest-10_0 && tar -tvf otobo.tar`` toont bestanden in een afbeelding

en	``docker exec -it nginx-server nginx -s reload`` reload nginx
nl	``docker exec -it nginx-server nginx -s reload`` herlaad nginx

en	**Docker Compose**

en	``docker-compose config`` check and show the configuration
nl	``docker-compose config`` controleer en toon de configuratie

en	``docker-compose ps`` show the running containers
nl	``docker-compose ps`` toont de draaiende containers

en	``docker-compose exec nginx nginx -s reload`` reload nginx
nl	``docker-compose exec nginx nginx -s reload`` herlaadt nginx

en	Resources
nl	Middel

en	Finally, here is a highly subjective collection of links.
nl	Tot slot, hier is een zeer subjectieve verzameling links.

en	**General info and tutorials**
nl	**Algemene informatie en tutorials**

en	`Perl Maven: Getting Started with Perl on Docker <https://perlmaven.com/getting-started-with-perl-on-docker>`_
nl	`Perl Maven: Aan de slag met Perl op Docker <https://perlmaven.com/getting-started-with-perl-on-docker>`_

en	`Dockerfile best practices <https://www.docker.com/blog/intro-guide-to-dockerfile-best-practices/>`_

en	`Environment <https://vsupalov.com/docker-arg-env-variable-guide/>`_
nl	`Omgeving <https://vsupalov.com/docker-arg-env-variable-guide/>`_

en	**Tips and hints**
nl	**Tips en hints**

en	`Clean up unused images <https://forums.docker.com/t/command-to-remove-all-unused-images>`_
nl	`Ruim ongebruikte afbeeldingen op <https://forums.docker.com/t/command-to-remove-all-unused-images>`_

en	`Docker Host IP <https://nickjanetakis.com/blog/docker-tip-65-get-your-docker-hosts-ip-address-from-in-a-container>`_

en	`Self signed certificate <https://www.digitalocean.com/community/tutorials/how-to-create-a-self-signed-ssl-certificate-for-nginx-in-ubuntu >`_
nl	`Zelfondertekend certificaat <https://www.digitalocean.com/community/tutorials/how-to-create-a-self-signed-ssl-certificate-for-nginx-in-ubuntu-18-04>`_

en	**Troubleshooting**
nl	**Probleemoplossing**

en	`Docker cache invalidation <https://stackoverflow.com/questions/34814669/when-does-docker-image-cache-invalidation-occur>`_
nl	`Docker cache-invalidering <https://stackoverflow.com/questions/34814669/when-does-docker-image-cache-invalidation-occur>`_

en	`Using tcpdump <https://rmoff.net/2019/11/29/using-tcpdump-with-docker/>`_
nl	`Met tcpdump <https://rmoff.net/2019/11/29/using-tcpdump-with-docker/>`_

en	`Inspect failed builds <https://pythonspeed.com/articles/debugging-docker-build/>`_
nl	`Inspecteer mislukte builds <https://pythonspeed.com/articles/debugging-docker-build/>`_

en	Installing Perl Modules from CPAN
nl	Perl Modules installeren vanaf CPAN

en	When there are special requirements then the need for additional Perl modules may arise. Fortunately, Perl has an excellent package repository that can satisfy almost all needs. That repository is called CPAN and is available at https://metacpan.org/.
nl	Als er speciale vereisten zijn, kan de behoefte aan extra Perl-modules ontstaan. Gelukkig heeft Perl een uitstekende pakketrepository die bijna alle behoeften kan vervullen. Die repository heet CPAN en is beschikbaar op https://metacpan.org/.

en	It is recommended to use the command line client ``cpanm`` for installing modules. ``cpanm`` is often already installed on your system. Please see https://metacpan.org/pod/App::cpanminus for what to do when is isn't already available.
nl	Het wordt aanbevolen om de command line client ``cpanm`` te gebruiken voor het installeren van modules. ``cpanm`` is vaak al geïnstalleerd op je systeem. Zie https://metacpan.org/pod/App::cpanminus voor wat te doen als het nog niet beschikbaar is.

en	Alternatively, many Perl modules are also available as packages for your operating system. These packages can be installed with your systems regular package manager.
nl	Als alternatief zijn veel Perl-modules ook beschikbaar als pakketten voor je besturingssysteem. Deze pakketten kunnen worden geïnstalleerd met de reguliere pakketbeheerder van je systeem.

en	Per default ``cpanm`` installs modules into a systemwide location. In this case modules must be installed as the root user. For example, the command
nl	Standaard installeert ``cpanm`` modules op een systeembrede locatie. In dit geval moeten modules als de rootgebruiker worden geïnstalleerd. Bijvoorbeeld, het commando

en	results in:
nl	resultaten in:

en	Docker-based installations
nl	Installaties gebaseerd op Docker

en	Special care must be taken when OTOBO runs under Docker. In this case an installation into a systemwide location would initially work as well. However, due to how Docker works, this installed modules would be lost when the container is restarted. Therefore the modules must be installed into a location that does survive a restart. The directory ``/opt/otobo/local`` within the volume **otobo_opt_otobo** can be used for that. Modules that are installed in ``/opt/otobo/local`` will be picked up by Perl because the environment variables ``PERL5LIB`` and ``PATH`` are preset accordingly.
nl	Speciale aandacht is vereist wanneer OTOBO draait onder Docker. In dit geval zou een installatie op een systeembrede locatie aanvankelijk ook werken. Echter, door de manier waarop Docker werkt, zouden deze geïnstalleerde modules verloren gaan wanneer de container opnieuw wordt gestart. Daarom moeten de modules geïnstalleerd worden op een locatie die een herstart overleeft. De map ``/opt/otobo/local`` binnen het volume **otobo_opt_otobo** kan hiervoor gebruikt worden. Modules die in ``/opt/otobo/local`` zijn geïnstalleerd, worden door Perl opgepikt omdat de omgevingsvariabelen ``PERL5LIB`` en ``PATH`` dienovereenkomstig zijn ingesteld.

en	The installed Perl modules will also be available after an upgrade of OTOBO. There is the general rule that files added to ``/opt/otobo`` won't be removed by an upgrade.
nl	De geïnstalleerde Perl-modules zullen ook beschikbaar zijn na een upgrade van OTOBO. Er is de algemene regel dat bestanden toegevoegd aan ``/opt/otobo`` niet verwijderd zullen worden door een upgrade.

en	For installing Perl modules in a specific location we need to modify our install command. Specifically, we need to add the option ``--local-lib``. Here is a sample session in the container **web**.
nl	Om Perl modules op een specifieke locatie te installeren moeten we ons installatiecommando aanpassen. Specifiek moeten we de optie ``--local-lib`` toevoegen. Hier is een voorbeeldsessie in de container **web**.

en	Introduction
nl	Introductie

en	OTOBO is an open source ticket request system with many features to manage customer telephone calls and emails. It is distributed under the GNU General Public License (GPL) and is tested on various Linux platforms.
nl	OTOBO is een open source ticketsysteem met veel functies om klantentelefoontjes en e-mails te beheren. Het wordt verspreid onder de GNU General Public License (GPL) en is getest op verschillende Linux-platformen.

en	About This Manual
nl	Over deze handleiding

en	This manual is intended for use by system administrators. The chapters describe the installation and updating of the OTOBO software.
nl	Deze handleiding is bedoeld voor gebruik door systeembeheerders. De hoofdstukken beschrijven de installatie en het updaten van de OTOBO-software.

en	There is no graphical user interface for installation and updating. System administrators have to follow the steps described in the following chapters.
nl	Er is geen grafische gebruikersinterface voor installatie en updates. Systeembeheerders moeten de stappen volgen die in de volgende hoofdstukken worden beschreven.

en	All console commands look like ``username> command-to-execute``. Username indicates the user account of the operating system, which need to use to execute the command. If a command starts with ``root>``, you have to execute the command as a user with root permissions. If a command starts with ``otobo>``, you have to execute the command as the user created for OTOBO.
nl	Alle console commando's zien eruit als ``gebruikersnaam> commando-om-uit-te-voeren``. Gebruikersnaam geeft het gebruikersaccount van het besturingssysteem aan, dat je moet gebruiken om het commando uit te voeren. Als een commando begint met ``root>``, moet je het commando uitvoeren als een gebruiker met rootrechten. Als een commando begint met ``otobo>``, moet je het commando uitvoeren als de gebruiker die voor OTOBO is aangemaakt.

en	Do not select ``username>`` when you copy the command and paste it to the shell. Otherwise you will get an error.
nl	Selecteer niet ``username>`` wanneer je het commando kopieert en plakt in de shell. Anders krijg je een foutmelding.

en	We assume that OTOBO will be installed to the directory ``/opt/otobo``. If you want to install OTOBO to a different location, then you have to change the path in the commands or create a symbolic link to this directory.
nl	We gaan ervan uit dat OTOBO wordt geïnstalleerd in de map ``/opt/otobo``. Als je OTOBO op een andere locatie wilt installeren, dan moet je het pad in de commando's wijzigen of een symbolische link naar deze map maken.

en	Migration from OTRS 6 or OTRS 7 / ((OTRS)) Community Edition to OTOBO version 10.1
nl	Migratie van OTRS / ((OTRS)) Community Edition versie 6 naar OTOBO versie 10.1

en	Please migrate your OTRS to OTOBO version 10.1 first and then upgrade your OTOBO to version 11.
nl	Migreer eerst je OTRS naar OTOBO versie 10.1 en upgrade dan je OTOBO naar versie 11.

en	Welcome and thank you for choosing OTOBO!
nl	Welkom en bedankt voor het kiezen van OTOBO!

en	OTRS, ((OTRS)) Community Edition and OTOBO are very comprehensive and flexible in their application. Thus, every migration to OTOBO requires thorough preparation and possibly some rework, too.
nl	OTRS, ((OTRS)) Community Edition en OTOBO zijn zeer uitgebreid en flexibel in hun toepassing. Daarom vereist elke migratie naar OTOBO een grondige voorbereiding en mogelijk ook wat herwerk.

en	Please take your time for the migration and follow these instructions step by step.
nl	Neem de tijd voor de migratie en volg deze instructies stap voor stap.

en	If you have any problem or question, please do not despair. Call our support line, write an email, or post your query in the OTOBO Community forum at https://forum.otobo.org/. We will find a way to help you!
nl	Als je een probleem of vraag hebt, wanhoop dan niet. Bel onze supportlijn, schrijf een e-mail, of plaats je vraag in het OTOBO Community forum op https://forum.otobo.org/. We vinden een manier om je te helpen!

en	After the migration the data previously available in OTRS will be available in OTOBO 10. We do not modify any data of the OTRS installation during the migration.
nl	Na de migratie zullen de gegevens die eerder beschikbaar waren in OTRS 6 beschikbaar zijn in OTOBO 10. We wijzigen geen gegevens van de OTRS 6-installatie tijdens de migratie.

en	Overview over the Supported Migration Szenarios
nl	Overzicht van de Ondersteunde Migratiescenario's

en	With the OTOBO Migration Interface it is possible to employ the following migration strategies:
nl	Met de OTOBO Migratie Interface is het mogelijk om de volgende migratiestrategieën te gebruiken:

en	The general migration strategy.
nl	De algemene migratiestrategie.

en	This is the regular way to perform a migration. Many different different combinations are supported:
nl	Dit is de reguliere manier om een migratie uit te voeren. Veel verschillende combinaties worden ondersteund:

en	Change server:
nl	Verander server:

en	Migrate and simultaneously move to a new application server.
nl	Migreer en verhuis tegelijkertijd naar een nieuwe applicatieserver.

en	Separate application and web servers:
nl	Scheid applicatie- en webservers:

en	It's your choice whether you want to run application and database server on the same host or each on a dedictated host. This choice is regardless of the previous setup in OTRS / ((OTRS)) Community Edition.
nl	Het is jouw keuze of je de applicatie- en databaseserver op dezelfde host wilt draaien of elk op een eigen toegewijde host. Deze keuze staat los van de eerdere setup in OTRS / ((OTRS)) Community Edition.

en	Different databases:
nl	Verschillende databases:

en	Migrate from any of the supported databases to any other supported database.
nl	Migreer van een van de ondersteunde databases naar een andere ondersteunde database.

en	Different operating system:
nl	Verschillend besturingssysteem:

en	Switch from any supported operating system to any other supported operating system.
nl	Overschakelen van elk ondersteund besturingssysteem naar een ander ondersteund besturingssysteem.

en	Docker:

en	Migrate to a Docker-based installation of OTOBO 10.
nl	Migreer naar een Docker-gebaseerde installatie van OTOBO 10.

en	A variant of the general strategy where the database migration is streamlined.
nl	Een variant van de algemene strategie waarbij de databasemigratie gestroomlijnd is.

en	Use the ETL-like migration when the source database mustn't suffer from increased load or when access to the source database is a bottleneck. In the general strategy, the data is row by row first read from the *otrs* database and then inserted into the OTOBO database. In this variant, the complete *otrs* database tables are first exported, then transformed, and then imported into the *otobo* database.
nl	Gebruik de ETL-achtige migratie wanneer de bron-database niet belast mag worden met extra lading of wanneer toegang tot de bron-database een knelpunt is. In de algemene strategie worden de gegevens rij voor rij eerst gelezen uit de *otrs* database en vervolgens ingevoegd in de OTOBO database. In deze variant worden de complete *otrs* databasetabellen eerst geëxporteerd, dan getransformeerd, en vervolgens geïmporteerd in de *otobo* database.

en	Migration from an Oracle based OTRS 6 / OTRS 7 installation to an Oracle based OTOBO installation.
nl	Migratie van een Oracle-gebaseerde OTRS 6-installatie naar een Oracle-gebaseerde OTOBO-installatie.

en	This is a special case that is not supported by the general migration strategy. This means that a variant of the streamlined strategy must be used.
nl	Dit is een speciaal geval dat niet wordt ondersteund door de algemene migratiestrategie. Dit betekent dat een variant van de gestroomlijnde strategie moet worden gebruikt.

en	All strategies work for both Docker-based and native installations. But for Docker-based installations some peculiarities have to be considered. These peculiarities are handled in the optional steps.
nl	Alle strategieën werken voor zowel Docker-gebaseerde als native installaties. Maar voor Docker-gebaseerde installaties moeten enkele eigenaardigheden worden overwogen. Deze eigenaardigheden worden behandeld in de optionele stappen.

en	It is also feasible to clone the OTRS datase to the OTOBO database server before the actual migration. This can speed up the general migration strategy.
nl	Het is ook mogelijk om de OTRS-database te klonen naar de OTOBO-databaseserver voordat de eigenlijke migratie plaatsvindt. Dit kan de algemene migratiestrategie versnellen.

en	Migration Requirements
nl	Migratievereisten

en	Basic requirement for a migration is that you already have an ((OTRS)) Community Edition or OTRS 6.0.\* / OTRS 7.0.\* running, and that you want to transfer both configuration and data to OTOBO.
nl	Basisvereiste voor een migratie is dat je al een ((OTRS)) Community Edition of OTRS 6.0.\* draaiend hebt, en dat je zowel configuratie als gegevens naar OTOBO wilt overzetten.

en	Please consider carefully whether you really need the data and configuration. Experience shows that quite often a new start is the better option. This is because in many cases the previously used installation and configuration was rather suboptimal anyways. It might also make sense to only transfer the ticket data and to change the basic configuration to OTOBO Best Practice. We are happy to advise you, please get in touch at hello@otobo.de or ask your question in the OTOBO Community forum at https://forum.otobo.org/.
nl	Denk goed na of je de data en configuratie echt nodig hebt. De ervaring leert dat een nieuwe start vaak de betere optie is. Dit komt omdat in veel gevallen de eerder gebruikte installatie en configuratie toch suboptimaal waren. Het kan ook zinvol zijn om alleen de ticketgegevens over te zetten en de basisconfiguratie te wijzigen naar OTOBO Best Practice. We adviseren je graag, neem contact op via hello@otobo.de of stel je vraag in het OTOBO Community forum op https://forum.otobo.org/.

en	You need a running OTOBO installation to start the migration from there!
nl	Je hebt een werkende OTOBO-installatie nodig om van daaruit de migratie te starten!

en	This OTOBO installation must contain all OPM packages installed in your OTRS that you want to use in OTOBO, too.
nl	Deze OTOBO-installatie moet alle OPM-pakketten bevatten die in je OTRS zijn geïnstalleerd en die je ook in OTOBO wilt gebruiken.

en	If you are planning to migrate to another server, then the OTOBO webserver must be able to access the location where your ((OTRS)) Community Edition or OTRS 6.0.* / OTRS 7.0.\* is installed. In most cases, this is the directory */opt/otrs* on the server running OTRS. The read access can be effected via SSH or via file system mounts.
nl	Als je van plan bent om naar een andere server te migreren, moet de OTOBO-webserver toegang hebben tot de locatie waar je ((OTRS)) Community Edition of OTRS 6.0.* is geïnstalleerd. In de meeste gevallen is dit de map */opt/otrs* op de server waar OTRS draait. De leestoegang kan via SSH of via bestandssysteemkoppelingen worden gerealiseerd.

en	The *otrs* database must be accessible from the server running OTOBO. Readonly access must be granted for external hosts. If access is not possible, or when the speed of the migration should be optimised, then a dump of the database is sufficient.
nl	De *otrs*-database moet toegankelijk zijn vanaf de server waarop OTOBO draait. Alleen-lezen toegang moet worden verleend voor externe hosts. Als toegang niet mogelijk is, of wanneer de snelheid van de migratie geoptimaliseerd moet worden, dan is een dump van de database voldoende.

en	If SSH and database access between the servers is not possible, please migrate OTRS to OTOBO on the same server and only then move the new installation.
nl	Als SSH- en databasetoegang tussen de servers niet mogelijk is, migreer dan OTRS naar OTOBO op dezelfde server en verplaats pas daarna de nieuwe installatie.

en	Step 1: Install the new OTOBO System
nl	Stap 1: Installeer het nieuwe OTOBO-systeem

en	Please start with installing a new OTOBO system. Your old OTRS / ((OTRS)) Community Edition installation will be migrated to that new system. We strongly recommend to read the chapter :doc:`installation`. For Docker-based installations we refer to the chapter :doc:`installation-docker`.
nl	Begin met het installeren van een nieuw OTOBO-systeem. Je oude OTRS / ((OTRS)) Community Edition-installatie zal naar dat nieuwe systeem gemigreerd worden. We raden je sterk aan om het hoofdstuk :doc:`installation` te lezen. Voor Docker-gebaseerde installaties verwijzen we naar het hoofdstuk :doc:`installation-docker`.

en	Under Apache, there are pitfalls with running two independent *mod_perl* applications under on the same webserver. Therefore, it is advised to run OTRS and OTOBO on separate webservers. Alternatively remove the OTRS configuration from Apache before installing OTOBO. Use the command ``a2query -s`` and check the directories */etc/apache2/sites-available* and */etc/apache2/sites-enabled* for inspecting which configurations are currently available and which are enabled.
nl	Onder Apache zijn er valkuilen bij het draaien van twee onafhankelijke *mod_perl* applicaties op dezelfde webserver. Daarom wordt geadviseerd om OTRS en OTOBO op aparte webservers te draaien. Verwijder alternatief de OTRS-configuratie van Apache voordat je OTOBO installeert. Gebruik het commando ``a2query -s`` en controleer de mappen */etc/apache2/sites-available* en */etc/apache2/sites-enabled* om te inspecteren welke configuraties momenteel beschikbaar zijn en welke zijn ingeschakeld.

en	After finishing the installation please log in as *root@localhost*. Navigate to the OTOBO Admin Area ``Admin -> Packages`` and install all required OTOBO OPM packages.
nl	Log na het afronden van de installatie in als *root@localhost*. Navigeer naar het OTOBO Admin-gebied ``Admin -> Pakketten`` en installeer alle vereiste OTOBO OPM-pakketten.

en	The following OPM packages and OTRS "Feature Addons" need NOT and should NOT be installed, as these features are already available in the OTOBO standard:
nl	De volgende OPM pakketten en OTRS "Feature Addons" hoeven NIET en moeten NIET worden geïnstalleerd, aangezien deze functies al beschikbaar zijn in de standaard OTOBO:

en	OTRSHideShowDynamicField

en	RotherOSSHideShowDynamicField

en	TicketForms

en	RotherOSS-LongEscalationPerformanceBoost

en	Znuny4OTRS-AdvancedDynamicFields

en	Znuny4OTRS-AutoSelect

en	Znuny4OTRS-EscalationSuspend

en	OTRSEscalationSuspend

en	OTRSDynamicFieldDatabase

en	OTRSDynamicFieldWebService

en	OTRSBruteForceAttackProtection

en	Znuny4OTRS-ExternalURLJump

en	Znuny4OTRS-QuickClose

en	Znuny4OTRS-AutoCheckbox

en	OTRSSystemConfigurationHistory

en	Znuny4OTRS-PasswordPolicy

en	The following OTOBO packages have been integrated into OTOBO 11.0. This means that they should not be installed in the target system when the target system is OTOBO 11.
nl	De volgende OTOBO pakketten zijn in OTOBO 11.0 geïntegreerd. Dit betekent dat ze niet geïnstalleerd moeten worden in het doelsysteem als het doelsysteem OTOBO 11 is.

en	ImportExport
nl	ImporterenExporteren

en	Step 2: Deactivate ``SecureMode`` on OTOBO
nl	Stap 2: Deactiveer ``SecureMode`` in OTOBO

en	After installing OTOBO, please log in again to the OTOBO Admin Area ``Admin -> System Configuration`` and deactivate the config option ``SecureMode``.
nl	Log na het installeren van OTOBO opnieuw in op het OTOBO Admin Gebied ``Admin -> Systeemconfiguratie`` en deactiveer de configuratieoptie ``SecureMode``.

en	Do not forget to actually deploy the changed setting.
nl	Vergeet niet om de gewijzigde instelling daadwerkelijk uit te rollen.

en	Step 3: Stop the OTOBO Daemon
nl	Stap 3: Stop de OTOBO Daemon

en	This is necessary when the OTOBO Daemon is actually running. Stopping the Daemon is different between Docker-based and non-Docker-based installations.
nl	Dit is noodzakelijk wanneer de OTOBO Daemon daadwerkelijk draait. Het stoppen van de Daemon verschilt tussen Docker-gebaseerde en niet-Docker-gebaseerde installaties.

en	In the non-Docker case execute the following commands as the user *otobo*:
nl	Voer in het geval van niet-Docker de volgende commando's uit als de gebruiker *otobo*:

en	When OTOBO is running in Docker, you just need to stop the service ``daemon``:
nl	Wanneer OTOBO in Docker draait, hoef je alleen de service ``daemon`` te stoppen:

en	It is recommended to run a backup of the whole OTOBO system at this point. If something goes wrong during migration, you will then not have to repeat the entire installation process, but can instead import the backup for a new migration.
nl	Het wordt aanbevolen om op dit punt een back-up van het hele OTOBO-systeem te maken. Als er iets misgaat tijdens de migratie, hoef je niet het hele installatieproces te herhalen, maar kun je in plaats daarvan de back-up importeren voor een nieuwe migratie.

en	We advise you to read the OTOBO :doc:`backup-restore` chapter.
nl	We adviseren je om het hoofdstuk OTOBO :doc:`backup-restore` te lezen.

en	Optional Step: Mount /opt/otrs for Convenient Access
nl	Optionele Stap: Koppel /opt/otrs voor Gemakkelijke Toegang

en	Often OTOBO should be running on a new server where */opt/otrs* isn't available initially. In these cases the directory */opt/otrs* on the OTRS server can be mounted into the file system of the OTOBO server. When a regular network mount is not possible, then using ``sshfs`` might be an option.
nl	Vaak moet OTOBO op een nieuwe server draaien waar */opt/otrs* in eerste instantie niet beschikbaar is. In deze gevallen kan de map */opt/otrs* op de OTRS-server worden gekoppeld aan het bestandssysteem van de OTOBO-server. Als een reguliere netwerkkoppeling niet mogelijk is, kan het gebruik van ``sshfs`` een optie zijn.

en	Optional Step: Install ``sshpass`` and ``rsync`` when */opt/otrs* Should be Copied via ssh
nl	Optionele Stap: Installeer ``sshpass`` en ``rsync`` wanneer */opt/otrs* via ssh gekopieerd moet worden

en	This step is only necessary when you want to migrate OTRS from another server and when */opt/otrs* from the remote server hasn't been mounted on the server running OTOBO.
nl	Deze stap is alleen nodig wanneer je OTRS wilt migreren vanaf een andere server en wanneer */opt/otrs* van de externe server niet is gekoppeld aan de server waarop OTOBO draait.

en	The tools ``sshpass`` and ``rsync`` are needed so that *migration.pl* can copy files via ssh. For installing ``sshpass``, please log in on the server as user ``root`` and execute one of the following commands:
nl	De tools ``sshpass`` en ``rsync`` zijn nodig zodat *migration.pl* bestanden via ssh kan kopiëren. Om ``sshpass`` te installeren, log je in op de server als gebruiker ``root`` en voer je een van de volgende commando's uit:

en	The same thing must be done for *rsync* when it isn't available yet.
nl	Hetzelfde moet gedaan worden voor *rsync* als het nog niet beschikbaar is.

en	Step 4: Preparing the OTRS / ((OTRS)) Community Edition system
nl	Stap 4: Het voorbereiden van het OTRS / ((OTRS)) Community Edition systeem

en	Be sure to have a valid backup of your OTRS / ((OTRS)) Community Edition system, too. Yes, we do not touch any OTRS data during the migration, but at times a wrong entry is enough to cause trouble.
nl	Zorg ervoor dat je een geldige back-up hebt van je OTRS / ((OTRS)) Community Edition systeem, ook. Ja, we raken geen OTRS-gegevens aan tijdens de migratie, maar soms kan een verkeerde invoer genoeg zijn om problemen te veroorzaken.

en	Now we are ready for the migration. First of all we need to make sure that no more tickets are processed and no users log on to OTRS:
nl	Nu zijn we klaar voor de migratie. Allereerst moeten we ervoor zorgen dat er geen tickets meer worden verwerkt en dat geen gebruikers inloggen op OTRS:

en	Please log in to the OTRS Admin Area ``Admin -> System Maintenance`` and add a new system maintenance slot for a few hours. After that, delete all agent and user sessions (``Admin -> Sessions``) and log out.
nl	Log in op het OTRS Admin Area ``Admin -> System Maintenance`` en voeg een nieuw systeemonderhoudsslot toe voor een paar uur. Verwijder daarna alle agent- en gebruikerssessies (``Admin -> Sessions``) en log uit.

en	Stop All Relevant Services and the OTRS Daemon
nl	Stop alle relevante services en de OTRS-daemon

en	Please make sure there are no running services or cron jobs.
nl	Zorg ervoor dat er geen lopende services of cronjobs zijn.

en	Clear the Caches and the Operational Data
nl	Wis de caches en operationele gegevens

en	The cached data and the operational data doesn't have to be migrated. The mail queue should at this point already be empty.
nl	De gecachte gegevens en de operationele gegevens hoeven niet gemigreerd te worden. De mailwachtrij zou op dit punt al leeg moeten zijn.

en	Optional Step for Docker: make required data available inside container
nl	Optionele stap voor Docker: maak de benodigde gegevens beschikbaar binnen de container

en	There are some specifics to be considered when your OTOBO installation is running under Docker. The most relevant: processes running in a Docker container generally cannot access directories outside the container. There is an exception though: directories mounted as volumes into the container can be accessed. Also, note that the MariaDB database running in ``otobo_db_1`` is not directly accessible from outside the container network.
nl	Er zijn enkele specifieke zaken om rekening mee te houden wanneer je OTOBO-installatie draait onder Docker. Het belangrijkste is: processen die in een Docker-container draaien, kunnen over het algemeen geen mappen buiten de container benaderen. Er is echter een uitzondering: mappen die als volumes in de container zijn gemount, kunnen wel worden benaderd. Let ook op dat de MariaDB-database die draait in ``otobo_db_1`` niet direct toegankelijk is van buiten het container netwerk.

en	In the sample commands, we assume that the user **docker_admin** is used for interacting with Docker. The Docker admin may be either the **root** user of the Docker host or a dedicated user with the required permissions.
nl	In de voorbeeldcommando's gaan we ervan uit dat de gebruiker **docker_admin** wordt gebruikt om met Docker te werken. De Docker-admin kan ofwel de **root**-gebruiker van de Docker-host zijn of een specifieke gebruiker met de benodigde rechten.

en	Copy */opt/otrs* into the volume *otobo_opt_otobo*
nl	Kopieer */opt/otrs* naar het volume *otobo_opt_otobo*

en	In this section, we assume that the OTRS home directory */opt/otrs* is available on the Docker host.
nl	In deze sectie gaan we ervan uit dat de OTRS-thuismap */opt/otrs* beschikbaar is op de Docker-host.

en	There are at least two viable possibilities:
nl	Er zijn ten minste twee haalbare mogelijkheden:

en	copy */opt/otrs* into the existing volume *otobo_opt_otobo*
nl	kopieer */opt/otrs* naar het bestaande volume *otobo_opt_otobo*

en	mount */opt/otrs* as an additional volume
nl	mount */opt/otrs* als een extra volume

en	Let's concentrate on option **a.** here.
nl	Laten we ons concentreren op optie **a.** hier.

en	First we need to find out where the volume *otobo_opt_otobo* is available on the Docker host.
nl	Eerst moeten we uitzoeken waar het volume *otobo_opt_otobo* beschikbaar is op de Docker host.

en	For safe copying, we use ``rsync``. Depending on your Docker setup, the command ``rsync`` might need to be run with ``sudo``.
nl	Voor veilig kopiëren gebruiken we ``rsync``. Afhankelijk van je Docker-setup moet het commando ``rsync`` mogelijk met ``sudo`` worden uitgevoerd.

en	This copied directory will be available as */opt/otobo/var/tmp/copied_otrs* within the container.
nl	Deze gekopieerde map zal beschikbaar zijn als */opt/otobo/var/tmp/copied_otrs* binnen de container.

en	Step 5: Perform the Migration!
nl	Stap 5: Voer de Migratie uit!

en	Please use the web migration tool at http://localhost/otobo/migration.pl. Be aware that you might have to replace "localhost" with your OTOBO hostname and you might have to add your non-standard port. The application then guides you through the migration process.
nl	Gebruik het webmigratiehulpmiddel op http://localhost/otobo/migration.pl. Let op dat je mogelijk "localhost" moet vervangen door je OTOBO-hostnaam en dat je mogelijk je niet-standaard poort moet toevoegen. De applicatie leidt je vervolgens door het migratieproces.

en	Sometimes, a warning is shown that the deactivation of **SecureMode** has not been detected. Please restart the webserver in this case. This forces the webserver to read in the current configuration.
nl	Soms wordt er een waarschuwing getoond dat de deactivatie van **SecureMode** niet is gedetecteerd. Herstart in dit geval de webserver. Dit dwingt de webserver om de huidige configuratie opnieuw in te lezen.

en	If OTOBO runs inside a Docker container, keep the default settings *localhost* for the OTRS server and */opt/otobo/var/tmp/copied_otrs* for the OTRS home directory. This is the path of the data that was copied in the optional step.
nl	Als OTOBO in een Docker container draait, houd dan de standaardinstellingen *localhost* voor de OTRS-server en */opt/otobo/var/tmp/copied_otrs* voor de OTRS-thuismap. Dit is het pad van de gegevens die gekopieerd zijn in de optionele stap.

en	The default values for OTRS database user and password are taken from *Kernel/Config.pm* in the OTRS home directory. Change the proposed settings if you are using a dedicated database user for the migration. Also change the settings when you work with a database that was copied into the *otobo_db_1* Docker container.
nl	De standaardwaarden voor OTRS-databasegebruiker en -wachtwoord worden overgenomen uit *Kernel/Config.pm* in de OTRS-hoofdmap. Wijzig de voorgestelde instellingen als je een specifieke databasegebruiker gebruikt voor de migratie. Wijzig ook de instellingen wanneer je werkt met een database die is gekopieerd naar de *otobo_db_1* Docker-container.

en	In the Docker case, a database running on the Docker host won't be reachable via ``127.0.0.1`` from within the Docker container. This means that the setting ``127.0.0.1`` won't be valid for the input field ``OTRS Server``. In that case, enter one of the alternative IP-addresses reported by the command ``hostname --all-ip-addresses`` for ``OTRS Server``.
nl	Als je Docker gebruikt, zal een database die op de Docker-host draait niet bereikbaar zijn via ``127.0.0.1`` vanuit de Docker-container. Dit betekent dat de instelling ``127.0.0.1`` niet geldig zal zijn voor het invoerveld ``OTRS Server``. Voer in dat geval een van de alternatieve IP-adressen in die worden weergegeven door het commando ``hostname --all-ip-addresses`` voor ``OTRS Server``.

en	When migrating to a new application server, or to a Docker-based installation, quite often the database cannot be accessed from the target installation. This is usually due to the fact that the otobo database user can only connect from the host the database runs on. In order to allow access anyways it is recommended to create a dedicated database user for the migration. E.g. ``CREATE USER 'otrs_migration'@'%' IDENTIFIED BY 'otrs_migration';`` and ``GRANT SELECT, SHOW VIEW ON otrs.* TO 'otrs_migration'@'%';``. This user can be dropped again after the migration: ``DROP USER 'otrs_migration'@'%'``.
nl	Bij het migreren naar een nieuwe applicatieserver, of naar een Docker-gebaseerde installatie, kan vaak de database niet worden benaderd vanaf de doelinstallatie. Dit komt meestal doordat de otobo-databasegebruiker alleen verbinding kan maken vanaf de host waarop de database draait. Om toch toegang te verlenen, wordt aanbevolen om een speciale databasegebruiker voor de migratie aan te maken. Bijvoorbeeld ``CREATE USER 'otrs_migration'@'%' IDENTIFIED BY 'otrs_migration';`` en ``GRANT SELECT, SHOW VIEW ON otrs.* TO 'otrs_migration'@'%';``. Deze gebruiker kan na de migratie weer verwijderd worden: ``DROP USER 'otrs_migration'@'%'``.

en	Custom settings in *Kernel/Config.pm* are carried over from the old OTRS installation to the new OTOBO installation. When you have custom settings, then please take a look at the migrated file */opt/otobo/Kernel/Config.pm*. You might want to adapt custom pathes or LDAP settings. In the best case you might find that some custom setting are longer needed.
nl	Aangepaste instellingen in *Kernel/Config.pm* worden overgedragen van de oude OTRS-installatie naar de nieuwe OTOBO-installatie. Als je aangepaste instellingen hebt, kijk dan naar het gemigreerde bestand */opt/otobo/Kernel/Config.pm*. Je wilt misschien aangepaste paden of LDAP-instellingen aanpassen. In het beste geval vind je dat sommige aangepaste instellingen niet meer nodig zijn.

en	When the migration is complete, please take your time and test the entire system. Once you have decided that the migration was successful and that you want to use OTOBO from now on, start the OTOBO Daemon:
nl	Als de migratie voltooid is, neem dan de tijd om het hele systeem te testen. Zodra je hebt besloten dat de migratie succesvol was en dat je vanaf nu OTOBO wilt gebruiken, start de OTOBO Daemon:

en	In the Docker case:
nl	In het Docker-geval:

en	Step 6: After Successful Migration!
nl	Stap 6: Na een succesvolle migratie!

en	Uninstall ``sshpass`` if you do not need it anymore.
nl	Verwijder ``sshpass`` als je het niet meer nodig hebt.

en	Drop the databases and database users dedicated to the migration if you created any.
nl	Verwijder de databases en databasegebruikers die zijn aangemaakt voor de migratie, als je die hebt gemaakt.

en	Have fun with OTOBO!
nl	Veel plezier met OTOBO!

en	Known Migration Problems
nl	Bekende migratieproblemen

en	1. Login after migration not possible
nl	1. Inloggen na migratie niet mogelijk

en	During our migration tests, the browser used for the migration sometimes had problems. After restarting the browser, this problem usually was solved. With Safari it was sometimes necessary to manually delete the old OTRS session.
nl	Tijdens onze migratietests had de browser die voor de migratie werd gebruikt soms problemen. Na het herstarten van de browser werd dit probleem meestal opgelost. Met Safari was het soms nodig om de oude OTRS-sessie handmatig te verwijderen.

en	2. Final page of the migration has a strange layout due to missing CSS files
nl	2. De laatste pagina van de migratie heeft een vreemde layout door ontbrekende CSS-bestanden

en	This can happen when the setting ScriptAlias has a non-standard value. The migration simply substitutes otrs for otobo. This might lead to the effect that the CSS and JavaScript can no longer be retrieved in OTOBO. When that happens, please check the settings in *Kernel/Config.pm* and revert them to sane values.
nl	Dit kan gebeuren wanneer de instelling ScriptAlias een niet-standaard waarde heeft. De migratie vervangt simpelweg otrs door otobo. Dit kan ertoe leiden dat de CSS en JavaScript niet meer opgehaald kunnen worden in OTOBO. Wanneer dat gebeurt, controleer dan de instellingen in *Kernel/Config.pm* en zet ze terug naar verstandige waarden.

en	3. Migration stops due to MySQL errors
nl	3. Migratie stopt vanwege MySQL-fouten

en	On systems that experienced problems with an upgrade in the past, the migration process may stop due to MySQL errors in the tables *ticket* and *ticket_history*. Usually these errors are NULL values in the source table that are no longer allowed in the target table. These conflicts have to be manually resolved before you can resume the migration.
nl	Op systemen die in het verleden problemen hebben ondervonden met een upgrade, kan het migratieproces stoppen vanwege MySQL-fouten in de tabellen *ticket* en *ticket_history*. Meestal zijn dit NULL-waarden in de brontabel die niet langer toegestaan zijn in de doeltabel. Deze conflicten moeten handmatig opgelost worden voordat je de migratie kunt hervatten.

en	There is a check in *migration.pl* that checks for NULL values before the data transfer is done. Note, that the resolution still needs to be performed manually.
nl	Vanaf OTOBO 10.0.12 is er een controle in *migration.pl* die controleert op NULL-waarden voordat de gegevensoverdracht wordt uitgevoerd. Let op, de oplossing moet nog steeds handmatig worden uitgevoerd.

en	4. Errors in Step 5 when migrating to PostgreSQL
nl	4. Fouten in Stap 5 bij migratie naar PostgreSQL

en	In these cases the not so helpful message "System was unable to complete data transfer." is shown by *migration.pl*. The Apache logfile, and the OTOBO logfile, show a more meaningful message: "Message: ERROR: permission denied to set parameter "session_replication_role", SQL: 'set session_replication_role to replica;'". In order to give the database user **otobo** the needed superuser privileges, run the following statement as the PostgreSQL admin: ``ALTER USER otobo WITH SUPERUSER;``. Then retry running http://localhost/otobo/migration.pl. After the migration, return to the normal state by running ``ALTER USER otobo WITH NOSUPERUSER``.
nl	In deze gevallen wordt het niet zo behulpzame bericht "Systeem kon de gegevensoverdracht niet voltooien." getoond door *migration.pl*. Het Apache-logbestand en het OTOBO-logbestand tonen een betekenisvollere boodschap: "Bericht: FOUT: toestemming geweigerd om parameter "session_replication_role" in te stellen, SQL: 'set session_replication_role to replica;'". Om de databasegebruiker **otobo** de benodigde superuser-privileges te geven, voer je de volgende opdracht uit als de PostgreSQL-admin: ``ALTER USER otobo WITH SUPERUSER;``. Probeer daarna http://localhost/otobo/migration.pl opnieuw uit te voeren. Na de migratie, ga terug naar de normale staat door ``ALTER USER otobo WITH NOSUPERUSER`` uit te voeren.

en	It is not clear yet, whether the extended privileges have to be granted in every setup.
nl	Het is nog niet duidelijk of de uitgebreide privileges in elke opstelling verleend moeten worden.

en	The discussion in https://otobo.de/de/forums/topic/otrs-6-mysql-migration-to-otobo-postgresql/.
nl	De discussie op https://otobo.de/de/forums/topic/otrs-6-mysql-migration-to-otobo-postgresql/.

en	5. Problems with the Deployment the Merged System Configuration
nl	5. Problemen met de implementatie van de samengevoegde systeemconfiguratie

en	The system configuration is migrated after the database tables were migrated. In this context, migration means merging the default settings of OTOBO with the system configuration of the source OTRS system. Inconsistencies can arise in this step. An real life example is the setting ``Ticket::Frontend::AgentTicketQuickClose###State``. This setting is new in OTOBO 10 and the default value is the state ``closed successful``. But this setting is invalid when the state ``closed successful`` has been dropped or renamed in the source system. This inconsistency is detected as an error in the migration step **Migrate configuration settings**. Actually, the merged system configuration is stored in the database, but additional validity checks are performed during deployment.
nl	De systeemconfiguratie wordt gemigreerd nadat de databasetabellen zijn gemigreerd. In deze context betekent migratie het samenvoegen van de standaardinstellingen van OTOBO met de systeemconfiguratie van het bron-OTRS-systeem. In deze stap kunnen inconsistenties ontstaan. Een echt voorbeeld is de instelling ``Ticket::Frontend::AgentTicketQuickClose###State``. Deze instelling is nieuw in OTOBO 10 en de standaardwaarde is de status ``closed successful``. Maar deze instelling is ongeldig als de status ``closed successful`` is verwijderd of hernoemd in het bronsysteem. Deze inconsistentie wordt gedetecteerd als een fout in de migratiestap **Migratie van configuratie-instellingen**. Eigenlijk wordt de samengevoegde systeemconfiguratie opgeslagen in de database, maar tijdens de implementatie worden extra geldigheidscontroles uitgevoerd.

en	The problem must be alleviated manually by using OTOBO console commands.
nl	Het probleem moet handmatig verlicht worden door gebruik te maken van OTOBO console commando's.

en	List the inconsistencies with the command ``bin/otobo.Console.pl Admin::Config::ListInvalid``
nl	Lijst de inconsistenties met het commando ``bin/otobo.Console.pl Admin::Config::ListInvalid``

en	Interactively fix the invalid values with ``bin/otobo.Console.pl Admin::Config::FixInvalid``
nl	Interactief de ongeldige waarden corrigeren met ``bin/otobo.Console.pl Admin::Config::FixInvalid``

en	Deploy the collected changes from migration.pl, including the deactivated **SecureMode** with ``bin/otobo.Console.pl Maint::Config::Rebuild``
nl	Implementeer de verzamelde wijzigingen van migration.pl, inclusief de gedeactiveerde **SecureMode** met ``bin/otobo.Console.pl Maint::Config::Rebuild``

en	After these manual steps you should be able to run *migration.pl* again. The migration will continue with the step where the error occurred.
nl	Na deze handmatige stappen zou je *migration.pl* opnieuw moeten kunnen uitvoeren. De migratie zal doorgaan met de stap waar de fout optrad.

en	Step 7: Manual Migration Tasks and Changes
nl	Stap 7: Handmatige migratietaken en wijzigingen

en	1. Password policy rules
nl	1. Regels voor wachtwoordbeleid

en	With OTOBO 10 a new default password policy for agent and customer users is in effect, if local authentication is used. The password policy rules can be changed in the system configuration (``PreferencesGroups###Password`` and ``CustomerPersonalPreference###Password``).
nl	Met OTOBO 10 is een nieuw standaard wachtwoordbeleid van kracht voor agent- en klantgebruikers, als lokale authenticatie wordt gebruikt. De regels van het wachtwoordbeleid kunnen worden gewijzigd in de systeemconfiguratie (``PreferencesGroups###Password`` en ``CustomerPersonalPreference###Password``).

en	Password Policy Rule
nl	Wachtwoordbeleidregel

en	Default
nl	Standaard

en	``PasswordMinSize``

en	8

en	``PasswordMin2Lower2UpperCharacters``

en	Yes
nl	Ja

en	``PasswordNeedDigit``

en	``PasswordHistory``

en	10

en	``PasswordTTL``

en	30 days
nl	3 dagen

en	``PasswordWarnBeforeExpiry``

en	5 days
nl	5 dagen

en	``PasswordChangeAfterFirstLogin``

en	2. Under Docker: Manually migrate cron jobs
nl	2. Onder Docker: Handmatig cronjobs migreren

en	In a non-Docker installation of OTOBO, there is at least one cron job which checks the health of the Daemon. Under Docker, this cron job no longer exists. Furthermore, there is no cron daemon running in any of the Docker containers. This means that you have to look for an individual solution for OTRS systems with customer-specific cron jobs (e. g. backing up the database).
nl	In een niet-Docker installatie van OTOBO is er ten minste één cronjob die de gezondheid van de Daemon controleert. Onder Docker bestaat deze cronjob niet meer. Bovendien draait er geen cron daemon in een van de Docker-containers. Dit betekent dat je een individuele oplossing moet zoeken voor OTRS-systemen met klantspecifieke cronjobs (bijv. het back-uppen van de database).

en	Special topics
nl	Speciale onderwerpen

en	Migration from Oracle to Oracle
nl	Migratie van Oracle naar Oracle

en	For migration to Oracle the ETL-like strategy must be employed. This is because Oracle provides no easy way to temporarily turn off foreign key checks.
nl	Voor migratie naar Oracle moet de ETL-achtige strategie worden toegepast. Dit komt omdat Oracle geen gemakkelijke manier biedt om tijdelijk de controle op vreemde sleutels uit te schakelen.

en	On the OTOBO host a Oracle client and the Perl module ``DBD::Oracle`` must be installed.
nl	Op de OTOBO host moet een Oracle client en de Perl module ``DBD::Oracle`` geïnstalleerd zijn.

en	When using the Oracle instant client, then the optional SDK is also needed for installing DBD::Oracle.
nl	Wanneer je de Oracle instant client gebruikt, is de optionele SDK ook nodig voor het installeren van DBD::Oracle.

en	There are many ways of cloning a schema. In the sample commands we use ``expdb`` and ``impdb`` which use Data Pump under the hood.
nl	Er zijn veel manieren om een schema te klonen. In de voorbeeldcommando's gebruiken we ``expdb`` en ``impdb``, die Data Pump gebruiken.

en	The connect strings shown in this documentation refer to the case when both source and target database run in a Docker container. See also https://github.com/bschmalhofer/otobo-ideas/blob/master/oracle.md .
nl	De verbindingsstrings die in deze documentatie worden getoond, verwijzen naar het geval waarbij zowel de bron- als de doeldatabase in een Docker-container draaien. Zie ook https://github.com/bschmalhofer/otobo-ideas/blob/master/oracle.md .

en	Clear out otobo
nl	Maak otobo leeg

en	Stop the webserver for otobo, so that the DB connection for otobo is closed.
nl	Stop de webserver voor otobo, zodat de DB-verbinding voor otobo wordt gesloten.

en	Export the complete OTRS schema.
nl	Exporteer het complete OTRS schema.

en	Import the OTRS schema, renaming the schema to 'otobo'.
nl	Importeer het OTRS-schema en hernoem het schema naar 'otobo'.

en	Adapt the cloned schema otobo
nl	Pas het gekloonde schema otobo aan

en	Start the web server for otobo again
nl	Start de webserver voor otobo opnieuw

en	Proceed with step 5, that is with running ``migration.pl``.
nl	Ga verder met stap 5, dat wil zeggen met het uitvoeren van ``migration.pl``.

en	If migrating to OTOBO version greater or equal 10.1 the script ``/opt/otobo/scripts/DBUpdate-to-10.1.pl`` has to be executed, to create the tables ``stats_report`` & ``data_storage``, which were newly added in version 10.1.
nl	Als je migreert naar OTOBO versie 10.1 of hoger moet het script ``/opt/otobo/scripts/DBUpdate-to-10.1.pl`` uitgevoerd worden, om de tabellen ``stats_report`` & ``data_storage`` aan te maken, die nieuw zijn toegevoegd in versie 10.1.

en	Optional Step: Streamlined migration of the database (only for experts and spezial scenarios)
nl	Optionele stap: Gestroomlijnde migratie van de database (alleen voor experts en speciale scenario's)

en	In the general migration strategy, all data in the database tables is copied row by row from the OTRS database into the OTOBO database. Exporting the data from the OTRS database and importing it into the OTOBO database might save time and is more stable in some circumstances.
nl	In de algemene migratiestrategie worden alle gegevens in de databasetabellen rij voor rij gekopieerd van de OTRS-database naar de OTOBO-database. Het exporteren van de gegevens uit de OTRS-database en het importeren ervan in de OTOBO-database kan tijd besparen en is in sommige omstandigheden stabieler.

en	This variant works for both Docker-based and native installations.
nl	Deze variant werkt voor zowel Docker-gebaseerde als native installaties.

en	These instructions assume that OTRS is using MySQL as its backend.
nl	Deze instructies gaan ervan uit dat OTRS MySQL gebruikt als backend.

en	First of all, we need a dump of the needed OTRS database tables. Then we need to perform a couple of transformations:
nl	Allereerst hebben we een dump nodig van de benodigde OTRS-databasetabellen. Vervolgens moeten we een aantal transformaties uitvoeren:

en	convert the character set to *utf8mb4*
nl	converteer de tekenset naar *utf8mb4*

en	rename a couple of tables
nl	hernoem een aantal tabellen

en	shorten some table columns
nl	verkort sommige tabelkolommen

en	After the transfomation we can overwrite the tables in the OTOBO schema with the transformed data from OTRS. Effectively we need not a single dump file, but several SQL scripts.
nl	Na de transformatie kunnen we de tabellen in het OTOBO-schema overschrijven met de getransformeerde gegevens van OTRS. Effectief hebben we niet één dumpbestand nodig, maar meerdere SQL-scripts.

en	When ``mysqldump`` is installed and a connection to the OTRS database is possible, you can create the database dump directly on the Docker host. This case is supported by the script *bin/backup.pl*.
nl	Wanneer ``mysqldump`` is geïnstalleerd en een verbinding met de OTRS-database mogelijk is, kun je direct op de Docker-host een database-dump maken. Dit geval wordt ondersteund door het script *bin/backup.pl*.

en	This requires that an OTOBO installation is available on the Docker host.
nl	Dit vereist dat er een OTOBO-installatie beschikbaar is op de Docker-host.

en	Alternatively, the database can be dumped on another server and then be transferred to the Docker host afterwards. An easy way to do this is to copy */opt/otobo* to the server running OTRS and perform the same command as above.
nl	Als alternatief kan de database op een andere server worden gedumpt en daarna naar de Docker-host worden overgebracht. Een eenvoudige manier om dit te doen is door */opt/otobo* te kopiëren naar de server waar OTRS draait en dezelfde opdracht als hierboven uit te voeren.

en	The script *bin/backup.pl* generates four SQL scripts in a dump directory, e.g. in *2021-04-13_12-13-04* In order to execute the SQL scripts, we need to run the command ``mysql``.
nl	Het script *bin/backup.pl* genereert vier SQL-scripts in een dumpmap, bijvoorbeeld in *2021-04-13_12-13-04*. Om de SQL-scripts uit te voeren, moeten we het commando ``mysql`` draaien.

en	Native installation:
nl	Native installatie:

en	Docker-based installation:
nl	Installatie gebaseerd op Docker:

en	Run the command ``mysql`` within the Docker container *db* for importing the database dump files. Note that the password for the database root is now the password that has been set up in the file *.env* on the Docker host.
nl	Voer het commando ``mysql`` uit binnen de Docker-container *db* voor het importeren van de database dumpbestanden. Let op dat het wachtwoord voor de database root nu het wachtwoord is dat is ingesteld in het bestand *.env* op de Docker-host.

en	For a quick check whether the import worked, you can run the following commands.
nl	Voor een snelle controle of de import is gelukt, kun je de volgende commando's uitvoeren.

en	or when running under Docker
nl	of wanneer het onder Docker draait

en	The database is now migrated. This means that during the next step we can skip the database migration. Watch out for the relevant checkbox.
nl	De database is nu gemigreerd. Dit betekent dat we tijdens de volgende stap de databasemigratie kunnen overslaan. Let op het relevante selectievakje.

en	Performance Tuning
nl	Prestatieafstemming

en	This is a list of performance enhancing techniques for your OTOBO installation. The topics include configuration, coding, memory use, and more.
nl	Dit is een lijst van prestatieverbeterende technieken voor je OTOBO-installatie. De onderwerpen omvatten configuratie, codering, geheugengebruik en meer.

en	Ticket Index Module

en	Ticket index module can be set via system configuration setting ``Ticket::IndexModule``. There are two back end modules building the index for the ticket queue view:
nl	Ticketindexmodule kan worden ingesteld via de systeemconfiguratie-instelling ``Ticket::IndexModule``. Er zijn twee backendmodules die de index bouwen voor de ticketwachtrijweergave:

en	``Kernel::System::Ticket::IndexAccelerator::RuntimeDB``

en	This is the default option, which will generate each queue view on the fly from the ticket table. You will not have performance trouble until you have about 60,000 open tickets in your system.
nl	Dit is de standaardoptie, die elke wachtrijweergave on-the-fly genereert uit de tickettabel. Je zult geen prestatieproblemen hebben totdat je ongeveer 60.000 open tickets in je systeem hebt.

en	``Kernel::System::Ticket::IndexAccelerator::StaticDB``

en	The most powerful module, should be used when you have above 80,000 open tickets. It uses an extra ``ticket_index`` table, which will be populated with keywords based on ticket data. Use the following command for generating an initial index after switching back ends:
nl	De krachtigste module, moet gebruikt worden als je meer dan 80.000 open tickets hebt. Het gebruikt een extra ``ticket_index`` tabel, die gevuld zal worden met sleutelwoorden gebaseerd op ticketgegevens. Gebruik het volgende commando om een initiële index te genereren na het wisselen van back-ends:

en	Ticket Search Index
nl	Ticket Zoekindex

en	OTOBO uses a special search index to perform full-text searches across fields in articles from different communication channels.
nl	OTOBO gebruikt een speciale zoekindex om volledige tekstzoekopdrachten uit te voeren in velden van artikelen uit verschillende communicatiekanalen.

en	To create an initial index, use this command:
nl	Om een initiële index te maken, gebruik je dit commando:

en	Actual article indexing happens via an OTOBO daemon job in the background. While articles which were just added in the system are marked for indexing immediately, it could happen their index is available only after a few minutes.
nl	De daadwerkelijke indexering van artikelen gebeurt via een OTOBO-daemonjob op de achtergrond. Hoewel artikelen die net aan het systeem zijn toegevoegd onmiddellijk worden gemarkeerd voor indexering, kan het gebeuren dat hun index pas na een paar minuten beschikbaar is.

en	There are some options available for fine-tuning the search index:
nl	Er zijn enkele opties beschikbaar voor het fijn afstellen van de zoekindex:

en	``Ticket::SearchIndex::IndexArchivedTickets``

en	Defines if archived tickets will be included in the search index (disabled by default). This is advisable to keep the index small on large systems with archived tickets. If this is enabled, archived tickets will be found by full-text searches.
nl	Bepaalt of gearchiveerde tickets worden opgenomen in de zoekindex (standaard uitgeschakeld). Dit is aan te raden om de index klein te houden op grote systemen met gearchiveerde tickets. Als dit is ingeschakeld, zullen gearchiveerde tickets worden gevonden door volledige tekstzoekopdrachten.

en	``Ticket::SearchIndex::Attribute``

en	Basic full-text index settings.
nl	Basisinstellingen voor volledige-tekstindex.

en	``Ticket::SearchIndex::Attribute`` Setting
nl	``Ticket::SearchIndex::Attribute`` Instelling

en	Run the following command in order to generate a new index:
nl	Voer het volgende commando uit om een nieuwe index te genereren:

en	``WordCountMax``

en	Defines the maximum number of words which will be processed to build up the index. For example only the first 1000 words of an article body are stored in the article search index.
nl	Definieert het maximale aantal woorden dat verwerkt zal worden om de index op te bouwen. Bijvoorbeeld, alleen de eerste 1000 woorden van een artikeltekst worden opgeslagen in de zoekindex van het artikel.

en	``WordLengthMin`` and ``WordLengthMax``
nl	``WordLengthMin`` en ``WordLengthMax``

en	Used as word length boundaries. Only words with a length between these two values are stored in the article search index.
nl	Gebruikt als woordlengtegrenzen. Alleen woorden met een lengte tussen deze twee waarden worden opgeslagen in de artikelzoekindex.

en	``Ticket::SearchIndex::Filters``

en	Filters based on regular expressions exclude parts of the original text from the full-text index.
nl	Filters op basis van reguliere expressies sluiten delen van de originele tekst uit van de volledige tekstindex.

en	``Ticket::SearchIndex::Filters`` Setting
nl	Instelling ``Ticket::SearchIndex::Filters``

en	There are three default filters defined:
nl	Er zijn drie standaardfilters gedefinieerd:

en	The first filter strips out special chars like: , & < > ? " ! * | ; [ ] ( ) + $ ^ =
nl	De eerste filter verwijdert speciale tekens zoals: , & < > ? " ! * | ; [ ] ( ) + $ ^ =

en	The second filter strips out words which begin or end with one of following chars: ' : .
nl	De tweede filter haalt woorden weg die beginnen of eindigen met een van de volgende tekens: ' : .

en	The third filter strips out words which do not contain a word character: a-z, A-Z, 0-9, _
nl	De derde filter haalt woorden weg die geen woordkarakter bevatten: a-z, A-Z, 0-9, _

en	``Ticket::SearchIndex::StopWords``

en	English stop words for full-text index. These words will be removed from the search index.
nl	Engelse stopwoorden voor volledige text zoek index. Deze woorden worden verwijderd van de zoek index.

en	``Ticket::SearchIndex::StopWords###en`` Setting
nl	Instelling ``Ticket::SearchIndex::StopWords###en``

en	There are so-called stop-words defined for some languages. These stop-words will be skipped while creating the search index.
nl	Er zijn zogenaamde stopwoorden gedefinieerd voor sommige talen. Deze stopwoorden worden overgeslagen bij het maken van de zoekindex.

en	If your language is not in the system configuration settings or you want to add more words, you can add them to this setting:
nl	Als je taal niet in de systeemconfiguratie-instellingen staat of je wilt meer woorden toevoegen, kun je ze aan deze instelling toevoegen:

en	``Ticket::SearchIndex::StopWords###Custom``

en	Document Search
nl	Documenten Zoeken

en	OTOBO uses Elasticsearch for its document search functionality. For a good introduction into the concepts, installation and usage of Elasticsearch, please follow the `Getting Started guide <https://www.elastic.co/guide/en/elasticsearch/reference/current/getting-started.html>`__.
nl	OTOBO gebruikt Elasticsearch voor zijn documentzoekfunctionaliteit. Voor een goede introductie in de concepten, installatie en gebruik van Elasticsearch, volg de `Getting Started gids <https://www.elastic.co/guide/en/elasticsearch/reference/current/getting-started.html>`__.

en	Heap Size
nl	Heapgrootte

en	Elasticsearch is written in Java and therefore runs in a Java Virtual Machine (JVM) on any cluster node. Such a JVM uses a part of the memory, called *heap*, which size can be configured in configuration file ``jvm.options``.
nl	Elasticsearch is geschreven in Java en draait daarom in een Java Virtual Machine (JVM) op elke clusternode. Zo'n JVM gebruikt een deel van het geheugen, genaamd *heap*, waarvan de grootte geconfigureerd kan worden in het configuratiebestand ``jvm.options``.

en	The heap minimum and maximum configurations are by default set to a value of 1 GB and can be modified with the following options:
nl	De minimale en maximale heapconfiguraties zijn standaard ingesteld op een waarde van 1 GB en kunnen worden aangepast met de volgende opties:

en	``Xms1g``: minimum heap size.
nl	``Xms1g``: minimale heapgrootte.

en	``Xmx1g``: maximum heap size.
nl	``Xmx1g``: maximale heapgrootte.

en	If the ``Xms`` has a lower value than ``Xmx``, the JVM will resize the used heap anytime the current limit is exceeded, until the value of ``Xmx`` is reached. Such a resizing causes the service to pause until it is finished, which may decrease the speed and reactivity of the search or indexing actions. Therefore it is highly recommended to set those configurations to an equal value.
nl	Als de ``Xms`` een lagere waarde heeft dan ``Xmx``, zal de JVM de gebruikte heap vergroten telkens wanneer de huidige limiet wordt overschreden, totdat de waarde van ``Xmx`` is bereikt. Zo'n vergroting veroorzaakt een pauze in de service totdat het klaar is, wat de snelheid en reactievermogen van de zoek- of indexeeracties kan verminderen. Daarom wordt het sterk aanbevolen om deze configuraties op een gelijke waarde in te stellen.

en	If the maximum heap size is exceeded, the related cluster node stops working and might even shutdown the service.
nl	Als de maximale heapgrootte wordt overschreden, stopt de gerelateerde clusternode met werken en kan zelfs de service afsluiten.

en	The higher the heap maximum value is set, the more memory can be used by Elasticsearch, which also increases the possible pauses for garbage collection, done by the JVM. Therefore it is recommended to set a value for ``Xmx``, that is not higher than 50% of the physical memory.
nl	Hoe hoger de maximale heapwaarde is ingesteld, hoe meer geheugen kan worden gebruikt door Elasticsearch, wat ook de mogelijke pauzes voor garbage collection door de JVM verhoogt. Daarom wordt aanbevolen om een waarde voor ``Xmx`` in te stellen die niet hoger is dan 50% van het fysieke geheugen.

en	For more information and good rules of thumb about the heap size, please follow `the official documentation <https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html>`__.
nl	Voor meer informatie en goede vuistregels over de heapgrootte, volg `de officiële documentatie <https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html>`__.

en	Disk Allocation
nl	Schijftoewijzing

en	While running the service, Elasticsearch inspects the available disk space. Based on the result, it decides whether to allocate new shards to a cluster node. In some cases it even relocates shards away from a node. This behavior is determined by the current disk capacity. It can be configured by settings in the configuration file *elasticsearch.yml*. Here are some relevant configuration settings. They come with good default values, but might be important in trouble shooting.
nl	Tijdens het draaien van de service controleert Elasticsearch de beschikbare schijfruimte. Op basis van het resultaat beslist het of het nieuwe shards toewijst aan een clusternode. In sommige gevallen verplaatst het zelfs shards weg van een node. Dit gedrag wordt bepaald door de huidige schijfcapaciteit. Het kan worden geconfigureerd door instellingen in het configuratiebestand *elasticsearch.yml*. Hier zijn enkele relevante configuratie-instellingen. Ze komen met goede standaardwaarden, maar kunnen belangrijk zijn bij het oplossen van problemen.

en	``cluster.routing.allocation.disk.watermark.low``

en	Default value of 85%. When this limit is exceeded, Elasticsearch will no longer allocate more shards to the related cluster node. The operation of that node is not influenced and data can still be indexed and searched.
nl	Standaardwaarde van 85%. Wanneer deze limiet wordt overschreden, zal Elasticsearch geen extra shards meer toewijzen aan de betreffende clusternode. De werking van die node wordt niet beïnvloed en gegevens kunnen nog steeds worden geïndexeerd en doorzocht.

en	``cluster.routing.allocation.disk.watermark.high``

en	Default value of 90%. When this limit is exceeded, Elasticsearch will try to relocate existing shards to other nodes that have enough space available.
nl	Standaardwaarde van 90%. Wanneer deze limiet wordt overschreden, zal Elasticsearch proberen bestaande shards te verplaatsen naar andere nodes die genoeg ruimte beschikbaar hebben.

en	``cluster.routing.allocation.disk.watermark.flood_stage``

en	Default value of 95%. When this limit is exceeded, Elasticsearch will update the configuration of all indices, that have at least one shard allocated to the related cluster node, to read-only index blocks. Specifically, they are flagged with ``index.blocks.read_only_allow_delete``.
nl	Standaardwaarde van 95%. Wanneer deze limiet wordt overschreden, zal Elasticsearch de configuratie van alle indices, die ten minste één shard toegewezen hebben aan de betreffende cluster node, bijwerken naar alleen-lezen indexblokken. Specifiek worden ze gemarkeerd met ``index.blocks.read_only_allow_delete``.

en	After that update, it is no longer possible to index new data to such indices. The indexes are restricted to searches and to delete actions only.
nl	Na die update is het niet meer mogelijk om nieuwe gegevens te indexeren naar dergelijke indices. De indexen zijn beperkt tot zoekacties en verwijderacties.

en	If the flood stage was exceeded and certain indices are configured to read-only mode, such configuration *will not* automatically be changed by Elasticsearch. If the related disks contain enough free space again due to manual actions, it is needed to change the configuration back to normal mode manually.
nl	Als de overstromingsfase is overschreden en bepaalde indices zijn ingesteld op alleen-lezen modus, zal deze configuratie *niet* automatisch worden gewijzigd door Elasticsearch. Als de gerelateerde schijven weer genoeg vrije ruimte bevatten door handmatige acties, moet de configuratie handmatig teruggezet worden naar de normale modus.

en	For more information about disk watermarks and disk-based shard allocation, please follow `the official documentation <https://www.elastic.co/guide/en/elasticsearch/reference/current/disk-allocator.html>`__.
nl	Voor meer informatie over schijfwatermerken en schijfgebaseerde shard-toewijzing, volg `de officiële documentatie <https://www.elastic.co/guide/en/elasticsearch/reference/current/disk-allocator.html>`__.

en	Article Storage
nl	Gemiddelde per interactie

en	There are two different back end modules for the article storage of phone, email and internal articles. The used article storage can be configured in the setting ``Ticket::Article::Backend::MIMEBase::ArticleStorage``.
nl	Er zijn twee verschillende backend-modules voor de opslag van artikelen van telefoon, e-mail en interne artikelen. De gebruikte artikelopslag kan worden geconfigureerd in de instelling ``Ticket::Article::Backend::MIMEBase::ArticleStorage``.

en	``Kernel::System::Ticket::Article::Backend::MIMEBase::ArticleStorageDB``

en	This default module will store attachments in the database. It also works with multiple front end servers, but requires much storage space in the database.
nl	Deze standaardmodule zal bijlagen in de database opslaan. Het werkt ook met meerdere front-end servers, maar vereist veel opslagruimte in de database.

en	Don't use this with large setups.
nl	Gebruik dit niet bij grote opstellingen.

en	``Kernel::System::Ticket::Article::Backend::MIMEBase::ArticleStorageFS``

en	Use this module to store attachments on the local file system. It is fast, but if you have multiple front end servers, you must make sure the file system is shared between the servers. Place it on an NFS share or preferably a SAN or similar solution.
nl	Gebruik deze module om bijlagen op te slaan op het lokale bestandssysteem. Het is snel, maar als je meerdere front-end servers hebt, moet je ervoor zorgen dat het bestandssysteem gedeeld wordt tussen de servers. Plaats het op een NFS-share of bij voorkeur een SAN of vergelijkbare oplossing.

en	Recommended for large setups.
nl	Aanbevolen voor grote opstellingen.

en	You can switch from one back end to the other on the fly. You can switch the back end in the system configuration, and then run this command line utility to put the articles from the database onto the file system or the other way around:
nl	Je kunt on-the-fly wisselen tussen de verschillende back-ends. Je kunt de back-end wijzigen in de systeemconfiguratie en vervolgens dit command-line hulpprogramma uitvoeren om de artikelen van de database naar het bestandssysteem te verplaatsen of andersom:

en	You can use the ``--target`` option to specify the target back end.
nl	Je kunt de optie ``--target`` gebruiken om het doel-backend te specificeren.

en	The entire process can take considerable time to run, depending on the number of articles you have and the available CPU power and/or network capacity.
nl	Het hele proces kan aanzienlijke tijd in beslag nemen, afhankelijk van het aantal artikelen dat je hebt en de beschikbare CPU-kracht en/of netwerkcapaciteit.

en	If you want to keep old attachments in the database, you can activate the system configuration option ``Ticket::Article::Backend::MIMEBase::CheckAllStorageBackends`` to make sure OTOBO will still find them.
nl	Als je oude bijlagen in de database wilt behouden, kun je de systeemconfiguratieoptie ``Ticket::Article::Backend::MIMEBase::CheckAllStorageBackends`` activeren om ervoor te zorgen dat OTOBO ze nog steeds kan vinden.

en	Archiving Tickets
nl	Tickets archiveren

en	As OTOBO can be used as an audit-proof system, deleting closed tickets may not be a good idea. Therefore there is a feature that allows you to archive tickets.
nl	Aangezien OTOBO als een audit-proof systeem gebruikt kan worden, is het misschien geen goed idee om gesloten tickets te verwijderen. Daarom is er een functie die je toestaat om tickets te archiveren.

en	Tickets that match certain criteria can be marked as archived. These tickets are not accessed if you do a regular ticket search or run a generic agent job. The system itself does not have to deal with a huge amount of tickets any longer as only the latest tickets are taken into consideration when using OTOBO. This can result in a huge performance gain on large systems.
nl	Tickets die aan bepaalde criteria voldoen, kunnen als gearchiveerd worden gemarkeerd. Deze tickets worden niet benaderd als je een reguliere ticketzoekopdracht uitvoert of een generieke agenttaak uitvoert. Het systeem hoeft niet langer om te gaan met een enorme hoeveelheid tickets, aangezien alleen de nieuwste tickets in overweging worden genomen bij het gebruik van OTOBO. Dit kan resulteren in een enorme prestatiewinst op grote systemen.

en	To use the archive feature:
nl	Om de archieffunctie te gebruiken:

en	Activate the ``Ticket::ArchiveSystem`` setting in the system configuration.
nl	Activeer de instelling ``Ticket::ArchiveSystem`` in de systeemconfiguratie.

en	Define a generic agent job:
nl	Definieer een generieke agenttaak:

en	Click on the *Add Job* button in the *Generic Agent* screen.
nl	Klik op de knop *Add Job* in het scherm *Generic Agent*.

en	*Job Settings*: provide a name for the archiving job.
nl	*Jobinstellingen*: geef een naam voor de archiveringsjob.

en	*Automatic Execution*: select proper options to schedule this job.
nl	*Automatische Uitvoering*: selecteer de juiste opties om deze taak te plannen.

en	*Select Tickets*: it might be a good idea to only archive those tickets in a closed state that have been closed a few months before.
nl	*Selecteer Tickets*: het is misschien een goed idee om alleen die tickets te archiveren die in een gesloten staat zijn en een paar maanden geleden zijn gesloten.

en	*Update/Add Ticket Attributes*: set the field *Archive selected tickets* to *archive tickets*.
nl	*Update/Toevoegen Ticketattributen*: stel het veld *Geselecteerde tickets archiveren* in op *tickets archiveren*.

en	Save the job at the end of the page.
nl	Sla de taak op aan het einde van de pagina.

en	Click on the *Run this task* link in the overview table to see the affected tickets.
nl	Klik op de link *Voer deze taak uit* in de overzichtstabel om de betrokken tickets te zien.

en	Click on the *Run Job* button.
nl	Klik op de *Run Job* knop.

en	Up to 5000 tickets can be modified by running this job manually.
nl	Tot 5000 tickets kunnen worden aangepast door deze job handmatig uit te voeren.

en	When you search for tickets, the system default is to search tickets which are not archived.
nl	Wanneer je zoekt naar tickets, is de systeemstandaard om te zoeken naar tickets die niet zijn gearchiveerd.

en	To search for archived tickets:
nl	Om naar gearchiveerde tickets te zoeken:

en	Open the ticket search screen.
nl	Open het ticketszoekscherm.

en	Set *Archive search* to *Unarchived tickets* or *All tickets*.
nl	Stel *Archief zoeken* in op *Niet-gearchiveerde tickets* of *Alle tickets*.

en	Perform the search.
nl	Voer de zoekopdracht uit.

en	Caching

en	A fast cache module is a great help in terms of performance. We recommend to use a Redis Cache server or to create a ramdisk.
nl	Een snelle cachemodule is een grote hulp in termen van prestaties. We raden aan om een Redis Cache server te gebruiken of een ramdisk te maken.

en	Install a Redis Cache Server
nl	Installeer een Redis Cache Server

en	Install Redis Server
nl	Installeer Redis Server

en	First of all you need to install the newest Redis Server. The easiest way is to `setup Redis <https://redis.io/topics/quickstart>`__ on the same host as OTOBO and binding it to its default port.
nl	Allereerst moet je de nieuwste Redis Server installeren. De makkelijkste manier is om `Redis op te zetten <https://redis.io/topics/quickstart>`__ op dezelfde host als OTOBO en het te binden aan de standaardpoort.

en	Install Perl module Redis or Redis::Fast
nl	Installeer Perl-module Redis of Redis::Fast

en	You can choose which Redis module to use: `Redis` or `Redis::Fast` (which is compatible with `Redis` but **~2x faster**). Please use ``otobo.CheckModules.pl --list`` to choose the right package for you:
nl	Je kunt kiezen welke Redis-module je wilt gebruiken: `Redis` of `Redis::Fast` (die compatibel is met `Redis` maar **~2x sneller**). Gebruik alstublieft ``otobo.CheckModules.pl --list`` om het juiste pakket voor jou te kiezen:

en	Configure OTOBO for Redis
nl	Configureer OTOBO voor Redis

en	Please use the OTOBO `SysConfig` (Admin -> System Configuration) to configure OTOBO properly:
nl	Gebruik de OTOBO `SysConfig` (Admin -> Systeemconfiguratie) om OTOBO correct te configureren:

en	RamDisk Caching

en	OTOBO caches a lot of temporary data in ``/opt/otobo/var/tmp``. Please make sure that this uses a high performance file system and storage. If you have enough RAM, you can also try to put this directory on a ramdisk like this:
nl	OTOBO slaat veel tijdelijke gegevens op in ``/opt/otobo/var/tmp``. Zorg ervoor dat dit gebruikmaakt van een hoogwaardig bestandssysteem en opslag. Als je genoeg RAM hebt, kun je ook proberen deze map op een ramdisk te plaatsen, zoals dit:

en	Add persistent mount point in ``/etc/fstab``.
nl	Voeg een persistent aankoppelpunt toe in ``/etc/fstab``.

en	This will be a non-permanent storage that will be lost on server reboot. All your sessions (if you store them in the file system) and your cache data will be lost.
nl	Dit zal een niet-permanente opslag zijn die verloren gaat bij een server herstart. Al je sessies (als je ze opslaat in het bestandssysteem) en je cachegegevens zullen verloren gaan.

en	Clustering

en	For very high loads, it can be required to operate OTOBO on a cluster of multiple front end servers. This is a complex task with many pitfalls. We strongly advise to get in touch with our experts before trying to implement this on your own.
nl	Voor zeer hoge belastingen kan het nodig zijn om OTOBO te bedienen op een cluster van meerdere front-end servers. Dit is een complexe taak met veel valkuilen. We raden je sterk aan om contact op te nemen met onze experts voordat je dit zelf probeert te implementeren.

en	Hardware and Software Requirements
nl	Hardware- en softwarevereisten

en	The OTOBO web application can be installed on Linux and other Unix derivates, e.g. OpenBSD or FreeBSD. Running OTOBO on Microsoft Windows is not supported.
nl	De OTOBO-webapplicatie kan worden geïnstalleerd op Linux en andere Unix-derivaten, bijv. OpenBSD of FreeBSD. Het draaien van OTOBO op Microsoft Windows wordt niet ondersteund.

en	The web application uses a relational database as backend. So, to run OTOBO, you'll need to run at least a web server and a database server. The web server and the database server may be installed either on the same or on different hosts.
nl	De webapplicatie gebruikt een relationele database als backend. Dus, om OTOBO te draaien, moet je minstens een webserver en een databaseserver draaien. De webserver en de databaseserver kunnen op dezelfde of op verschillende hosts geïnstalleerd zijn.

en	Alternatively, OTOBO can also run under Docker. When running under Docker, the web and the database server are already included in the setup. Support for deployment with Kubernetes is under development.
nl	Als alternatief kan OTOBO ook onder Docker draaien. Wanneer het onder Docker draait, zijn de web- en databaseserver al in de setup inbegrepen. Ondersteuning voor implementatie met Kubernetes is in ontwikkeling.

en	The OTOBO web application requires Perl along with additional Perl modules from CPAN. The modules can be installed either with a Perl package manager or via the package manager of your operating system (rpm, yast, apt-get). There is a console command for checking the module dependencies:
nl	De OTOBO-webapplicatie vereist Perl samen met aanvullende Perl-modules van CPAN. De modules kunnen geïnstalleerd worden met een Perl-pakketbeheerder of via de pakketbeheerder van je besturingssysteem (rpm, yast, apt-get). Er is een consolecommando om de moduleafhankelijkheden te controleren:

en	If some packages are missing, you can get an install command for your operating system by running the script with the ``--list`` option.
nl	Als er pakketten ontbreken, kun je een installatiecommando voor je besturingssysteem krijgen door het script uit te voeren met de optie ``--list``.

en	The listed commands should then be executed with root privileges.
nl	De vermelde commando's moeten dan worden uitgevoerd met rootbevoegdheden.

en	The output of the module check script shows the installed packages and the version numbers. Missing modules are marked with a comment.
nl	De uitvoer van het modulecontrolescript toont de geïnstalleerde pakketten en de versienummers. Ontbrekende modules zijn gemarkeerd met een opmerking.

en	Hardware Requirements
nl	Hardwarevereisten

en	Hardware requirements highly depend on the usage of OTOBO. OTOBO can be used to process a few tickets per month or to process hundreds of tickets per day. The storage requirement also depends on the number of tickets and size of attachments.
nl	Hardwarevereisten hangen sterk af van het gebruik van OTOBO. OTOBO kan worden gebruikt om een paar tickets per maand te verwerken of om honderden tickets per dag te verwerken. De opslagvereiste hangt ook af van het aantal tickets en de grootte van de bijlagen.

en	We recommend using a machine for testing purposes with **at least**:
nl	We raden aan om voor testdoeleinden een machine te gebruiken met **minstens**:

en	small CPU
nl	kleine CPU

en	4 GB RAM

en	10 GB storage
nl	10 GB opslag

en	We recommend using a machine for production purpose with **at least**:
nl	We raden aan om voor productiedoeleinden minimaal een machine te gebruiken met:

en	3 GHz Xeon or comparable CPU
nl	3 GHz Xeon of vergelijkbare CPU

en	8 GB RAM (16 GB recommend)
nl	8 GB RAM (16 GB aanbevolen)

en	40 GB storage
nl	40 GB opslag

en	Hardware requirements depend on the usage of OTOBO. Please contact your OTOBO consultant before deploying any hardware.
nl	Hardwarevereisten zijn afhankelijk van het gebruik van OTOBO. Neem contact op met je OTOBO-consultant voordat je hardware implementeert.

en	Software requirements
nl	Softwarevereisten

en	Perl

en	Perl 5.24.0 or higher
nl	Perl 5.24.0 of hoger

en	Perl packages listed by ``/opt/otobo/bin/otobo.CheckModules.pl --list`` console command
nl	Perl-pakketten vermeld door het consolecommando ``/opt/otobo/bin/otobo.CheckModules.pl --list``

en	Web Server
nl	Webserver

en	Apache HTTP Server Version 2.4
nl	Apache HTTP Server Versie 2.4

en	Databases
nl	Database

en	MySQL 5.6 or higher
nl	MySQL 5.6 of hoger

en	MariaDB

en	PostgreSQL 9.2 or higher
nl	PostgreSQL 9.2 of hoger

en	Oracle 10g or higher
nl	Oracle 10g of hoger

en	Optional
nl	Optioneel

en	Elasticsearch 7.x (fast search function for live previews)
nl	Elasticsearch 7.x (snelle zoekfunctie voor live previews)

en	Redis (fast caching)
nl	Redis (snelle caching)

en	nginx or any other web server that can be used as a reverse proxy (SSL support and load distribution)
nl	nginx of een andere webserver die als reverse proxy kan worden gebruikt (SSL-ondersteuning en lastverdeling)

en	Web browsers
nl	Webbrowsers

en	Apple Safari

en	Google Chrome

en	Microsoft Internet Explorer 11

en	Microsoft Edge

en	Mozilla Firefox

en	Any other modern web browser with JavaScript support
nl	Elke andere moderne webbrowser met JavaScript-ondersteuning

en	Kerberos Single Sign On in OTOBO Docker installation
nl	Kerberos Single Sign On in OTOBO Docker installatie

en	Please read to the chapter :doc:`installation-docker` for basic information about installing and configure OTOBO. This tutorial assumes that OTOBO has been installed and configured using Docker.
nl	Lees het hoofdstuk :doc:`installation-docker` voor basisinformatie over het installeren en configureren van OTOBO. Deze handleiding gaat ervan uit dat OTOBO is geïnstalleerd en geconfigureerd met Docker.

en	In the following, we will refer from AD (Active Directory), of course the Kerberos configuration is also possible under LDAP.
nl	In het volgende zullen we verwijzen naar AD (Active Directory), natuurlijk is de Kerberos-configuratie ook mogelijk onder LDAP.

en	Generate Active Directory User
nl	Genereer Active Directory Gebruiker

en	Please create a new Active Directory User with the following settings and save the marked settings:
nl	Maak een nieuwe Active Directory-gebruiker aan met de volgende instellingen en sla de gemarkeerde instellingen op:

en	Please use as Username only this syntax: `HTTP/fqdn.from.your.otobo.de`. `fqdn.from.your.otobo.de` needs to be a A-Record DNS entry, not a CNAME! In the next step, it is also possible to use other URLs for OTOBO, they must then point as CNAME to our A-record defined above.
nl	Gebruik als gebruikersnaam alleen deze syntaxis: `HTTP/fqdn.from.your.otobo.de`. `fqdn.from.your.otobo.de` moet een A-record DNS-invoer zijn, geen CNAME! In de volgende stap is het ook mogelijk om andere URL's voor OTOBO te gebruiken, deze moeten dan als CNAME naar ons hierboven gedefinieerde A-record wijzen.

en	The username part "HTTP/" should be written in capital letters, as Kerberos expects it that way.
nl	Het gebruikersnaamdeel "HTTP/" moet in hoofdletters geschreven worden, zoals Kerberos dat verwacht.

en	The password doesn't work properly with some special characters (e.g. '&').
nl	Het wachtwoord werkt niet goed met sommige speciale tekens (bijv. '&').

en	You have to create a seperate AD-user. You can not use the one that you already use for your LDAP/AD sync.
nl	Je moet een aparte AD-gebruiker aanmaken. Je kunt niet degene gebruiken die je al gebruikt voor je LDAP/AD-synchronisatie.

en	Generate Active Directory Keytab file
nl	Genereer Active Directory Keytab-bestand

en	In the next step, we connect to a domain controller of the Active Directory and open a console (cmd) there with administrator privileges. Now we use the tool `ktpass.exe`to generate the needed keytab file:
nl	In de volgende stap verbinden we met een domeincontroller van de Active Directory en openen we daar een console (cmd) met beheerdersrechten. Nu gebruiken we het hulpprogramma `ktpass.exe` om het benodigde keytab-bestand te genereren:

en	`-princ = HTTP/otrs32-centos6.otrs.local@OTRS.LOCAL -> Picture Number 1+@+Picture Number 2`
nl	`-princ = HTTP/otrs32-centos6.otrs.local@OTRS.LOCAL -> Afbeelding Nummer 1+@+Afbeelding Nummer 2`

en	`-mapuser = OTRS\otrs32-centos6 (Username prä Win 2000) -> -> Picture Number 3+\+Picture Number`
nl	`-mapuser = OTRS\otrs32-centos6 (Gebruikersnaam prä Win 2000) -> -> Afbeelding Nummer 3+\+Afbeelding Nummer`

en	`-pass = Password from user otrs32-centos6 (Active Directory User)`
nl	`-pass = Wachtwoord van gebruiker otrs32-centos6 (Active Directory Gebruiker)`

en	`-out = c:/krb5.keytab`

en	Please write the domain (@OTRS.LOCAL) always in capital letters. The password must not contain some special characters.
nl	Schrijf het domein (@OTRS.LOCAL) altijd in hoofdletters. Het wachtwoord mag sommige speciale tekens niet bevatten.

en	In the next step please move the krb5.keytab file to the OTOBO Server:
nl	Verplaats in de volgende stap het krb5.keytab-bestand naar de OTOBO-server:

en	Create a new volume for your custom nginx configuration
nl	Maak een nieuw volume voor je aangepaste nginx-configuratie

en	Create new OTOBO .env file
nl	Maak een nieuw OTOBO .env-bestand

en	First of all we need to move the old file ``/opt/otobo-docker/.env`` to ``.env.tmp`` and create a new ``.env`` file including the kerberos settings.
nl	Allereerst moeten we het oude bestand ``/opt/otobo-docker/.env`` verplaatsen naar ``.env.tmp`` en een nieuw ``.env`` bestand aanmaken inclusief de kerberos-instellingen.

en	Now copy your existing configuration options to the new .env file (at least OTOBO_DB_ROOT_PASSWORD, OTOBO_NGINX_SSL_CERTIFICATE, OTOBO_NGINX_SSL_CERTIFICATE_KEY) and insert the following Kerberos settings:
nl	Kopieer nu je bestaande configuratieopties naar het nieuwe .env-bestand (minstens OTOBO_DB_ROOT_PASSWORD, OTOBO_NGINX_SSL_CERTIFICATE, OTOBO_NGINX_SSL_CERTIFICATE_KEY) en voeg de volgende Kerberos-instellingen in:

en	# Kerberos keytab OTOBO_NGINX_KERBEROS_KEYTAB=/opt/otobo-docker/nginx-conf/krb5.keytab

en	# Kerberos config (Important, please comment out this option like here!) # In default configuration the krb5.conf file is generated automatically # OTOBO_NGINX_KERBEROS_CONFIG=/opt/otobo-docker/nginx-conf/krb5.conf
nl	# Kerberos-configuratie (Belangrijk, zet deze optie uit zoals hier!) # In de standaardconfiguratie wordt het krb5.conf-bestand automatisch gegenereerd # OTOBO_NGINX_KERBEROS_CONFIG=/opt/otobo-docker/nginx-conf/krb5.conf

en	# Kerberos Service Name OTOBO_NGINX_KERBEROS_SERVICE_NAME=HTTP/otrs32-centos6.otrs.local # -> Picture Number 1
nl	# Kerberos Service Naam OTOBO_NGINX_KERBEROS_SERVICE_NAME=HTTP/otrs32-centos6.otrs.local # -> Afbeelding Nummer 1

en	# Kerberos REALM OTOBO_NGINX_KERBEROS_REALM=ROTHER-OSS.COM -> OTRS.LOCAL # -> Picture Number 2
nl	# Kerberos REALM OTOBO_NGINX_KERBEROS_REALM=ROTHER-OSS.COM -> OTRS.LOCAL # -> Afbeelding Nummer 2

en	# Active Directory Domain Controller / Kerberos kdc OTOBO_NGINX_KERBEROS_KDC=

en	# Active Directory Domain Controller / Kerberos Admin Server OTOBO_NGINX_KERBEROS_ADMIN_SERVER=rother-oss.com

en	# Kerberos Default Domain OTOBO_NGINX_KERBEROS_DEFAULT_DOMAIN=otrs.local
nl	# Kerberos Standaard Domein OTOBO_NGINX_KERBEROS_DEFAULT_DOMAIN=otrs.local

en	Start OTOBO

en	After the initial Kerberos configuration we start OTOBO again:
nl	Na de initiële Kerberos configuratie starten we OTOBO opnieuw:

en	Tell OTOBO to use the Kerberos-Authentication
nl	Zeg OTOBO om Kerberos-authenticatie te gebruiken

en	In case you have configured AD-Authentication, de-activate it (e.g. by commenting out the respective lines from your Kernel/Config.pm). The authentication will not take place via LDAP anymore.
nl	In het geval dat je AD-authenticatie hebt geconfigureerd, deactiveer het (bijvoorbeeld door de betreffende regels uit je Kernel/Config.pm te commentariëren). De authenticatie zal niet meer via LDAP plaatsvinden.

en	To use Kerberos-Authentication take the Kerberos-lines from Kernel/Config/Defaults.pm and put it into you Kernel/Config.pm E.g. these lines could work:
nl	Om Kerberos-authenticatie te gebruiken, neem je de Kerberos-regels uit Kernel/Config/Defaults.pm en zet je ze in je Kernel/Config.pm Bijvoorbeeld, deze regels zouden kunnen werken:

en	Configure Browser to understand Kerberos SSO
nl	Configureer de browser om Kerberos SSO te begrijpen

en	For SSO to work, the browser must be configured accordingly.
nl	Voor SSO om te werken, moet de browser dienovereenkomstig geconfigureerd zijn.

en	**Chrome, Edge, Internet Explorer, etc.**

en	Add page under local or trusted pages and activate 'Integrated Windows Authentication' (Internet Options).
nl	Voeg pagina toe onder lokale of vertrouwde pagina's en activeer 'Geïntegreerde Windows-authenticatie' (Internetopties).

en	**Firefox**

en	Enter "about:config" in the firefox address line
nl	Voer "about:config" in de adresbalk van Firefox in

en	and change the following settings:
nl	en wijzig de volgende instellingen:

en	network.negotiate-auth.trusted-uris = https:// (or https://otobofqdn)
nl	network.negotiate-auth.trusted-uris = https:// (of https://otobofqdn)

en	network.negotiate-auth.delegation-uris = http:// (or https://otobofqdn)
nl	network.negotiate-auth.delegation-uris = http:// (of https://otobofqdn)

en	Debugging and Problems
nl	Debuggen en Problemen

en	If the Kerberos SSO does not work, please check first if the NGINX container is started:
nl	Als Kerberos SSO niet werkt, controleer dan eerst of de NGINX-container is gestart:

en	In the next step please check the NGINX logs for more information:
nl	Controleer in de volgende stap de NGINX logs voor meer informatie:

en	If NGINX is running, please login into the NGINX Container and check all needed files:
nl	Als NGINX draait, log dan in op de NGINX Container en controleer alle benodigde bestanden:

en	Kerberos debugging

en	Now you are able to debug the Kerberos settings. Examples:
nl	Nu kun je de Kerberos-instellingen debuggen. Voorbeelden:

en	In case you stumble upon the issue that apparently the authentication works but the agent is not yet in the database, then your sync (if implemented) might not work. An error 52e (First bind failed) indicates that something is wrong with your Search User. This happens if you use the same user for the AD sync and as a SSO user. Please use seperate AD users for that. In order to not have to create a new keytab and having to repeat the steps mentioned above, it could be easier to create a new user to use in your AD sync (probably in your Kernel/Config.pm).
nl	Als je het probleem tegenkomt dat de authenticatie blijkbaar werkt maar de agent nog niet in de database staat, dan werkt je synchronisatie (indien geïmplementeerd) misschien niet. Een fout 52e (Eerste binding mislukt) geeft aan dat er iets mis is met je Zoekgebruiker. Dit gebeurt als je dezelfde gebruiker gebruikt voor de AD-synchronisatie en als een SSO-gebruiker. Gebruik aparte AD-gebruikers hiervoor. Om niet een nieuwe keytab te hoeven maken en de bovengenoemde stappen te herhalen, kan het makkelijker zijn om een nieuwe gebruiker te maken voor je AD-synchronisatie (waarschijnlijk in je Kernel/Config.pm).

en	In case SSO is not working properly, make sure: * the user for which it is not working is in Active Directory * the system has to be in the domain * it is properly stated as a trusted page (see 'Configure Browser to understand Kerberos SSO')
nl	Als SSO niet goed werkt, zorg ervoor dat: * de gebruiker voor wie het niet werkt in Active Directory staat * het systeem in het domein moet zijn * het duidelijk is aangegeven als een vertrouwde pagina (zie 'Configureer Browser om Kerberos SSO te begrijpen')

en	Updating
nl	Bijwerken

en	It is highly recommended to perform a test update on a separate testing machine first.
nl	Het wordt ten zeerste aanbevolen om eerst een testupdate uit te voeren op een aparte testmachine.

en	On Debian systems you may need to manually install some perl packages before upgrading to 11.0.
nl	Op Debian-systemen moet je mogelijk handmatig enkele perl-pakketten installeren voordat je upgrade van 10.0 naar 10.1

en	Step 1: Stop All Relevant Services and the OTOBO Daemon
nl	Stap 1: Stop alle relevante services en de OTOBO-daemon

en	Please make sure there are no more running services or cron jobs that try to access OTOBO. This will depend on your service configuration.
nl	Zorg ervoor dat er geen lopende services of cronjobs meer zijn die proberen toegang te krijgen tot OTOBO. Dit hangt af van je serviceconfiguratie.

en	Stop OTOBO cron jobs and the daemon (in this order):
nl	Stop OTOBO cronjobs en de daemon (in deze volgorde):

en	Step 2: Backup Files and Database
nl	Stap 2: Back-up bestanden en database

en	Create a backup of the hole ``/opt/otobo`` directory and the database.
nl	Maak een back-up van de hele ``/opt/otobo`` map en de database.

en	Example for a standard installation with Ubuntu and MySQL
nl	Voorbeeld voor een standaardinstallatie met Ubuntu en MySQL

en	Please check if all files are valid. Now we have a backup with all required data.
nl	Controleer of alle bestanden geldig zijn. Nu hebben we een back-up met alle benodigde gegevens.

en	Don't proceed without a complete backup of your system. You can use also the :doc:`backup-restore` script for this.
nl	Ga niet verder zonder een volledige back-up van je systeem. Je kunt hiervoor ook het :ref:`backup-restore` script gebruiken.

en	Step 2.1: Delete CPAN-directory if you are upgrading from 10.1
nl	Stap 2.1: CPAN-directory verwijderen als u een upgrade uitvoert vanaf 10.1

en	If you are upgrading from 10.1 to 11.0 you need to clean the cpan-lib directory, since some of the cpan libraries have changed.
nl	Als u een upgrade uitvoert van 10.1 naar 11.0 moet u de cpan-lib directory opschonen, omdat sommige cpan bibliotheken zijn veranderd.

en	Step 3: Install the New Release
nl	Stap 3: Installeer de Nieuwe Release

en	Download the latest otobo release from https://ftp.otobo.org/pub/otobo/. and unpack the source archive (for example, using ``tar``) into the directory ``/root/otobo-update``:
nl	Download de laatste otobo-release van https://ftp.otobo.org/pub/otobo/. en pak het bronarchief uit (bijvoorbeeld met ``tar``) in de map ``/root/otobo-update``:

en	Restore Old Configuration Files
nl	Herstel oude configuratiebestanden

en	We need only copy the file ``Kernel/Config.pm`` in OTOBO 10.
nl	We hoeven alleen het bestand ``Kernel/Config.pm`` te kopiëren in OTOBO 10.

en	Restore Article Data
nl	Herstel Artikelgegevens

en	If you configured OTOBO to store article data in the file system you have to restore the ``article`` folder to ``/opt/otobo/var/`` or the folder specified in the system configuration.
nl	Als je OTOBO hebt geconfigureerd om artikelgegevens op te slaan in het bestandssysteem, moet je de ``article`` map herstellen naar ``/opt/otobo/var/`` of de map die is opgegeven in de systeemconfiguratie.

en	Restore Already Installed Default Statistics
nl	Herstel al geïnstalleerde standaardstatistieken

en	If you have additional packages with default statistics you have to restore the stats XML files with the suffix ``*.installed`` to ``/opt/otobo/var/stats``.
nl	Als je extra pakketten met standaardstatistieken hebt, moet je de stats XML-bestanden met de suffix ``*.installed`` herstellen naar ``/opt/otobo/var/stats``.

en	Set File Permissions
nl	Stel bestandsrechten in

en	Check Apache configuration files
nl	Controleer Apache-configuratiebestanden

en	Newer versions of OTOBO may need you to adjust the apache configuration. From version 10.1 and onwards we moved from CGI to PSGI. Take a look at ``scripts/apache2-httpd-vhost-443.include.conf`` to see what settings needs to be adjusted/added.
nl	Nieuwere versies van OTOBO vereisen mogelijk dat je de Apache-configuratie aanpast. Vanaf versie 10.1 zijn we overgestapt van CGI naar PSGI. Bekijk ``scripts/apache2-httpd-vhost-443.include.conf`` om te zien welke instellingen aangepast/toegevoegd moeten worden.

en	Step 4: Check for new needed Perl modules
nl	Stap 4: Controleer op nieuwe benodigde Perl-modules

en	OTOBO needs new cpan packages for some version jumps. Please check if new packages are needed and install them if necessary.
nl	OTOBO heeft nieuwe cpan pakketten nodig voor sommige versiesprongen. Controleer of nieuwe pakketten nodig zijn en installeer ze indien nodig.

en	On Debian systems you may need to manually install some packages:
nl	Op Debian systemen moet je mogelijk handmatig enkele pakketten installeren:

en	Step 5: Update Installed Packages and reconfigure config
nl	Stap 5: Update geïnstalleerde pakketten en configureer de configuratie opnieuw

en	You can use the command below to update all installed packages. This works for all packages that are available from online repositories. You can update other packages later via the package manager (this requires a running OTOBO daemon).
nl	Je kunt het onderstaande commando gebruiken om alle geïnstalleerde pakketten bij te werken. Dit werkt voor alle pakketten die beschikbaar zijn vanuit online repositories. Je kunt andere pakketten later bijwerken via de pakketbeheerder (dit vereist een werkende OTOBO-daemon).

en	Step 6: Only for minor or major release upgrades (for example to upgrade from 10.1 to 11.0)
nl	Stap 6: Alleen voor kleine of grote release-upgrades (bijvoorbeeld om te upgraden van 10.0 naar 10.1)

en	Step 7: Start your Services
nl	Stap 7: Start je Services

en	Start OTOBO cron jobs and the daemon (in this order):
nl	Start OTOBO cronjobs en de daemon (in deze volgorde):

en	Now the services can be started. This will depend on your service configuration, here is an example:
nl	Nu kunnen de services worden gestart. Dit is afhankelijk van je serviceconfiguratie, hier is een voorbeeld:

en	Now you can log into your system.
nl	Nu kun je inloggen op je systeem.

en	Updating a Docker-based Installation of OTOBO
nl	Een Docker-gebaseerde installatie van OTOBO bijwerken

en	Don't update without a complete backup of your system. You can use the :doc:`backup-restore-docker` script in your existing Docker installation for that.
nl	Ga niet verder zonder een volledige back-up van je systeem. Je kunt hiervoor ook het :ref:`backup-restore` script gebruiken.

en	For running OTOBO under Docker we need the OTOBO software itself and an environment in which OTOBO can run. The OTOBO Docker image provides the environment and a copy of the OTOBO software. The software itself is installed in the volume *otobo_opt_otobo*. A named volume is used because run time data, e.g. configuration files and installed packages, is stored in the same directory tree.
nl	Voor het draaien van OTOBO onder Docker hebben we de OTOBO-software zelf nodig en een omgeving waarin OTOBO kan draaien. Het OTOBO Docker-image biedt de omgeving en een kopie van de OTOBO-software. De software zelf is geïnstalleerd in het volume *otobo_opt_otobo*. Een benoemd volume wordt gebruikt omdat runtime data, bijvoorbeeld configuratiebestanden en geïnstalleerde pakketten, in dezelfde directorystructuur worden opgeslagen.

en	When updating to a new version of OTOBO several things have to happen.
nl	Bij het updaten naar een nieuwe versie van OTOBO moeten verschillende dingen gebeuren.

en	The Docker Compose files have to be updated.
nl	De Docker Compose-bestanden moeten worden bijgewerkt.

en	The Docker Compose config file *.env* has to be checked.
nl	Het Docker Compose configuratiebestand *.env* moet worden gecontroleerd.

en	The new Docker image has to be fetched.
nl	De nieuwe Docker-afbeelding moet worden opgehaald.

en	The volume *otobo_opt_otobo* must be updated.
nl	Het volume *otobo_opt_otobo* moet worden bijgewerkt.

en	Some maintainance tasks must be executed.
nl	Sommige onderhoudstaken moeten worden uitgevoerd.

en	In the sample commands below, the version **11.x.y**, corresponding to the tag **11_x_y**, is used as the example version. Please substitute it with the real version, e.g. **11.0.2**.
nl	In de onderstaande voorbeeldcommando's wordt de versie **10.x.y**, overeenkomend met de tag **10_x_y**, gebruikt als voorbeeldversie. Vervang dit alstublieft door de echte versie, bijvoorbeeld **10.0.7**.

en	Updating the Docker Compose files
nl	De Docker Compose-bestanden bijwerken

en	The OTOBO Docker Compose files can change between releases. Therefore is must be made sure that the correct setup is used.
nl	De OTOBO Docker Compose-bestanden kunnen veranderen tussen releases. Daarom moet worden gezorgd dat de juiste setup wordt gebruikt.

en	See https://hub.docker.com/r/rotheross/otobo/tags for the available releases.
nl	Zie https://hub.docker.com/r/rotheross/otobo/tags voor de beschikbare releases.

en	Checking the Docker Compose .env file
nl	Het Docker Compose .env-bestand controleren

en	The file *.env* controls the OTOBO Docker container. Within that file, the variables *OTOBO_IMAGE_OTOBO*, *OTOBO_IMAGE_OTOBO_ELASTICSEARCH*, and *OTOBO_IMAGE_OTOBO_NGINX* declare which images are used. The latest images are used when these variables are not set. If you want to use a specific version, then please set these variables accordingly.
nl	Het bestand *.env* beheert de OTOBO Docker-container. Binnen dat bestand verklaren de variabelen *OTOBO_IMAGE_OTOBO*, *OTOBO_IMAGE_OTOBO_ELASTICSEARCH*, en *OTOBO_IMAGE_OTOBO_NGINX* welke afbeeldingen worden gebruikt. De nieuwste afbeeldingen worden gebruikt wanneer deze variabelen niet zijn ingesteld. Als je een specifieke versie wilt gebruiken, stel deze variabelen dan dienovereenkomstig in.

en	Fetch the new Docker images
nl	Haal de nieuwe Docker-images op

en	Docker compose can be used for fetching the wanted images from https://hub.docker.com/r/rotheross/otobo/.
nl	Docker compose kan worden gebruikt om de gewenste afbeeldingen van https://hub.docker.com/r/rotheross/otobo/ te halen.

en	Update OTOBO

en	Please note that minor or major upgrades must always be carried out one after the other. If you would like to upgrade from version 10.0.* to the latest 11.0.*, please upgrade to 10.1 first and then to 11.0.
nl	Houd er rekening mee dat kleine of grote upgrades altijd na elkaar moeten worden uitgevoerd. Als je wilt upgraden van versie 10.0.* naar de nieuwste 11.0.*, upgrade dan eerst naar 10.1 en daarna naar 11.0.

en	In this step the volume *otobo_opt_otobo* is updated and the following OTOBO console commands are performed:
nl	In deze stap wordt het volume *otobo_opt_otobo* bijgewerkt en worden de volgende OTOBO-consolecommando's uitgevoerd:

en	Admin::Package::ReinstallAll

en	Admin::Package::UpgradeAll

en	Maint::Config::Rebuild
nl	Onderhoud::Config::Opnieuw opbouwen

en	Maint::Cache::Delete

en	For minor and major version upgrades, prior to this also update tasks for the core system have to be performed
nl	Voor kleine en grote versie-upgrades moeten eerst ook updatetaken voor het kernsysteem worden uitgevoerd

en	For simple patchlevel updates (e.g. 11.0.2 to 11.0.3) running the above mentioned commands can be automated with the help of the script *scripts/update.sh*. This script runs the commands starting with the **docker-compose pull** command. Note that that calling the database upgrade scripts is not included and therefor it cannot be used for version upgrades.
nl	Voor eenvoudige updates op patchlevel (bijv. 11.0.2 naar 11.0.3) kan het uitvoeren van de bovenstaande commando's worden geautomatiseerd met behulp van het script *scripts/update.sh*. Dit script voert de commando's uit die beginnen met het **docker-compose pull** commando. Merk op dat het aanroepen van de database upgrade scripts niet is inbegrepen en daarom kan het niet worden gebruikt voor versie upgrades.

en	When upgrading from 10.1.x to 11.0.x with the ITSM plugin installed, the following command has to be executed additionally:
nl	Bij het upgraden van 10.1.x naar 11.0.x met de ITSM-plugin geïnstalleerd, moet de volgende opdracht aanvullend worden uitgevoerd: