2016-01-24 20:15:50 -05:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
*****
|
2016-01-24 20:15:50 -05:00
|
|
|
Setup
|
2020-11-13 18:46:19 +01:00
|
|
|
*****
|
2016-01-24 20:15:50 -05:00
|
|
|
|
|
|
|
|
Download
|
2020-11-13 18:46:19 +01:00
|
|
|
########
|
2016-01-24 20:15:50 -05:00
|
|
|
|
2016-03-19 12:20:36 +00:00
|
|
|
The source is currently only available via GitHub, so grab it from there,
|
2020-11-13 18:46:19 +01:00
|
|
|
by using ``git``:
|
2016-01-24 20:15:50 -05:00
|
|
|
|
|
|
|
|
.. code:: bash
|
|
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
$ git clone https://github.com/jonaswinkler/paperless-ng.git
|
2016-01-24 20:15:50 -05:00
|
|
|
$ cd paperless
|
|
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
Installation
|
|
|
|
|
############
|
2016-01-24 20:15:50 -05:00
|
|
|
|
2018-04-24 22:19:37 +02:00
|
|
|
You can go multiple routes with setting up and running Paperless:
|
|
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
* The `docker route`_
|
|
|
|
|
* The `bare metal route`_
|
2018-04-24 22:19:37 +02:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
The recommended setup route is docker, since it takes care of all dependencies
|
|
|
|
|
for you.
|
2018-04-24 22:19:37 +02:00
|
|
|
|
2018-10-13 11:31:53 -07:00
|
|
|
The `docker route`_ is quick & easy.
|
2018-04-24 22:19:37 +02:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
The `bare metal route`_ is more complicated to setup but makes it easier
|
2018-04-24 22:19:37 +02:00
|
|
|
should you want to contribute some code back.
|
2016-01-24 20:15:50 -05:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
Docker Route
|
|
|
|
|
============
|
2019-11-03 18:24:03 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
1. Install `Docker`_ and `docker-compose`_. [#compose]_
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. caution::
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
If you want to use the included ``docker-compose.yml.example`` file, you
|
|
|
|
|
need to have at least Docker version **17.09.0** and docker-compose
|
|
|
|
|
version **1.17.0**.
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
See the `Docker installation guide`_ on how to install the current
|
|
|
|
|
version of Docker for your operating system or Linux distribution of
|
|
|
|
|
choice. To get an up-to-date version of docker-compose, follow the
|
|
|
|
|
`docker-compose installation guide`_ if your package repository doesn't
|
|
|
|
|
include it.
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. _Docker installation guide: https://docs.docker.com/engine/installation/
|
|
|
|
|
.. _docker-compose installation guide: https://docs.docker.com/compose/install/
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
2. Create a copy of ``docker-compose.yml.example`` as ``docker-compose.yml``
|
|
|
|
|
and a copy of ``docker-compose.env.example`` as ``docker-compose.env``.
|
|
|
|
|
You'll be editing both these files: taking a copy ensures that you can
|
|
|
|
|
``git pull`` to receive updates without risking merge conflicts with your
|
|
|
|
|
modified versions of the configuration files.
|
|
|
|
|
3. Modify ``docker-compose.yml`` to your preferences. You should change the path
|
|
|
|
|
to the consumption directory in this file. Find the line that specifies where
|
|
|
|
|
to mount the consumption directory:
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. code::
|
|
|
|
|
|
|
|
|
|
- ./consume:/usr/src/paperless/consume
|
|
|
|
|
|
|
|
|
|
Replace the part BEFORE the colon with a local directory of your choice:
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. code::
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
- /home/jonaswinkler/paperless-inbox:/usr/src/paperless/consume
|
|
|
|
|
|
|
|
|
|
Don't change the part after the colon or paperless wont find your documents.
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
|
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
4. Modify ``docker-compose.env``, following the comments in the file. The
|
|
|
|
|
most important change is to set ``USERMAP_UID`` and ``USERMAP_GID``
|
|
|
|
|
to the uid and gid of your user on the host system. This ensures that
|
|
|
|
|
both the docker container and you on the host machine have write access
|
|
|
|
|
to the consumption directory. If your UID and GID on the host system is
|
|
|
|
|
1000 (the default for the first normal user on most systems), it will
|
|
|
|
|
work out of the box without any modifications.
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
5. Run ``docker-compose up -d``. This will create and start the necessary
|
|
|
|
|
containers.
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
6. To be able to login, you will need a super user. To create it, execute the
|
|
|
|
|
following command:
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. code-block:: shell-session
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
$ docker-compose run --rm webserver createsuperuser
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
This will prompt you to set a username, an optional e-mail address and
|
|
|
|
|
finally a password.
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
7. The default ``docker-compose.yml`` exports the webserver on your local port
|
|
|
|
|
8000. If you haven't adapted this, you should now be able to visit your
|
|
|
|
|
Paperless instance at ``http://127.0.0.1:8000``. You can login with the
|
|
|
|
|
user and password you just created.
|
Add Dockerfile for application and documentation
This commit adds a `Dockerfile` to the root of the project, accompanied
by a `docker-compose.yml.example` for simplified deployment. The
`Dockerfile` is agnostic to whether it will be the webserver, the
consumer, or if it is run for a one-off command (i.e. creation of a
superuser, migration of the database, document export, ...).
The containers entrypoint is the `scripts/docker-entrypoint.sh` script.
This script verifies that the required permissions are set, remaps the
default users and/or groups id if required and installs additional
languages if the user wishes to.
After initialization, it analyzes the command the user supplied:
- If the command starts with a slash, it is expected that the user
wants to execute a binary file and the command will be executed
without further intervention. (Using `exec` to effectively replace
the started shell-script and not have any reaping-issues.)
- If the command does not start with a slash, the command will be
passed directly to the `manage.py` script without further
modification. (Again using `exec`.)
The default command is set to `--help`.
If the user wants to execute a command that is not meant for `manage.py`
but doesn't start with a slash, the Docker `--entrypoint` parameter can
be used to circumvent the mechanics of `docker-entrypoint.sh`.
Further information can be found in `docs/setup.rst` and in
`docs/migrating.rst`.
For additional convenience, a `Dockerfile` has been added to the `docs/`
directory which allows for easy building and serving of the
documentation. This is documented in `docs/requirements.rst`.
2016-02-17 18:45:04 +01:00
|
|
|
|
|
|
|
|
.. _Docker: https://www.docker.com/
|
|
|
|
|
.. _docker-compose: https://docs.docker.com/compose/install/
|
|
|
|
|
|
|
|
|
|
.. [#compose] You of course don't have to use docker-compose, but it
|
|
|
|
|
simplifies deployment immensely. If you know your way around Docker, feel
|
|
|
|
|
free to tinker around without using compose!
|
|
|
|
|
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
Bare Metal Route
|
|
|
|
|
================
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. warning::
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
TBD. User docker for now.
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
Migration to paperless-ng
|
|
|
|
|
#########################
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
At its core, paperless-ng is still paperless and fully compatible. However, some
|
|
|
|
|
things have changed under the hood, so you need to adapt your setup depending on
|
|
|
|
|
how you installed paperless. The important things to keep in mind are as follows.
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
* Read the :ref:`paperless_changelog` and take note of breaking changes.
|
|
|
|
|
* It is recommended to use postgresql as the database now. The docker-compose
|
|
|
|
|
deployment will automatically create a postgresql instance and instruct
|
|
|
|
|
paperless to use it. This means that if you use the docker-compose script
|
|
|
|
|
with your current paperless media and data volumes and used the default
|
|
|
|
|
sqlite database, **it will not use your sqlite database and it may seem
|
|
|
|
|
as if your documents are gone**. You may use the provided
|
|
|
|
|
``docker-compose.yml.sqlite.example`` script, which does not use postgresql.
|
|
|
|
|
* The task scheduler of paperless, which is used to execute periodic tasks
|
|
|
|
|
such as email checking and maintenance, requires a `redis`_ message broker
|
|
|
|
|
instance. The docker-compose route takes care of that.
|
|
|
|
|
* The layout of the folder structure for your documents and data remains the
|
|
|
|
|
same.
|
|
|
|
|
* The frontend needs to be built from source. The docker image takes care of
|
|
|
|
|
that.
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
Migration to paperless-ng is then performed in a few simple steps:
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
1. Do a backup for two purposes: If something goes wrong, you still have your
|
|
|
|
|
data. Second, if you don't like paperless-ng, you can switch back to
|
|
|
|
|
paperless.
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
2. Replace the paperless source with paperless-ng. If you're using git, this
|
|
|
|
|
is done by:
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. code:: bash
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
$ git remote set-url origin https://github.com/jonaswinkler/paperless-ng
|
|
|
|
|
$ git pull
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
3. If you are using docker, copy ``docker-compose.yml.example`` to
|
|
|
|
|
``docker-compose.yml`` and ``docker-compose.env.example`` to
|
|
|
|
|
``docker-compose.env``. Make adjustments to these files as necessary.
|
|
|
|
|
See `docker route`_ for details.
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
4. Update paperless. See :ref:`administration-updating` for details.
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
5. Start paperless-ng.
|
2016-03-19 01:57:54 -07:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. code:: bash
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
$ docker-compose up
|
|
|
|
|
|
|
|
|
|
This will also migrate your database as usual. Verify by inspecting the
|
|
|
|
|
output that the migration was successfully executed. CTRL-C will then
|
|
|
|
|
gracefully stop the container. After that, you can start paperless-ng as
|
|
|
|
|
usuall with
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. code:: bash
|
2016-08-21 10:44:52 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
$ docker-compose up -d
|
2016-08-21 10:44:52 +01:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
6. Paperless installed a permanent redirect to ``admin/`` in your browser. This
|
|
|
|
|
redirect is still in place and prevents access to the new UI. Clear
|
|
|
|
|
everything related to paperless in your browsers data in order to fix
|
|
|
|
|
this issue.
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
Moving data from sqlite to postgresql
|
|
|
|
|
=====================================
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. warning::
|
2016-03-19 12:20:36 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
TBD.
|
2019-01-20 21:19:43 +00:00
|
|
|
|
2020-11-13 18:46:19 +01:00
|
|
|
.. _redis: https://redis.io/
|
