Dockerfile to build and run XWiki on docker
XWiki is a free wiki software platform written in Java with a design emphasis on extensibility. XWiki is an enterprise wiki. It includes WYSIWYG editing, OpenDocument based document import/export, semantic annotations and tagging, and advanced permissions management.
As an application wiki, XWiki allows for the storing of structured data and the execution of server side script within the wiki interface. Scripting languages including Velocity, Groovy, Python, Ruby and PHP can be written directly into wiki pages using wiki macros. User-created data structures can be defined in wiki documents and instances of those structures can be attached to wiki documents, stored in a database, and queried using either Hibernate query language or XWiki's own query language.
XWiki.org's extension wiki is home to XWiki extensions ranging from code snippets which can be pasted into wiki pages to loadable core modules. Many of XWiki Enterprise's features are provided by extensions which are bundled with it.
The goal is to provide a production-ready XWiki system running in Docker. This is why:
You should first install Docker on your machine.
Then there are several options:
You need to run 2 containers:
Start by creating a dedicated docker network:
docker network create -d bridge xwiki-nw
Then run a container for the database and make sure it's configured to use an UTF8 encoding. The following databases are supported out of the box:
We will bind mount two local directories to be used by the MySQL container: - one to be used at database initialization to set permissions (see below), - another to contain the data put by XWiki inside the MySQL database, so that when you stop and restart MySQL you don't find yourself without any data.
For example: -
/my/path/mysql-init-
/my/path/mysql
You need to make sure these directories exist, and then create a file under the
/my/path/mysql-initdirectory (you can name it the way you want, for example
init.sql), with the following content:
grant all privileges on *.* to [email protected]'%'
This will provide enough permissions for the
xwikiuser to create new schemas which is required to be able to create sub-wikis.
Note: Make sure the directories you are mounting into the container are fully-qualified, and aren't relative paths.
docker run --net=xwiki-nw --name mysql-xwiki -v /my/path/mysql:/var/lib/mysql -v /my/path/mysql-init:/docker-entrypoint-initdb.d -e MYSQL_ROOT_PASSWORD=xwiki -e MYSQL_USER=xwiki -e MYSQL_PASSWORD=xwiki -e MYSQL_DATABASE=xwiki -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin --explicit-defaults-for-timestamp=1
You should adapt the command line to use the passwords that you wish for the MySQL root password and for the
xwikiuser password (make sure to also change the GRANT command).
Notes:
If you're using MySQL8, you also need to configure the
mysql_native_passwordauthentication plugin the native password mechanism that XWiki uses to connect:
docker run --net=xwiki-nw --name mysql-xwiki -v /my/path/mysql:/var/lib/mysql -v /my/path/mysql-init:/docker-entrypoint-initdb.d -e MYSQL_ROOT_PASSWORD=xwiki -e MYSQL_USER=xwiki -e MYSQL_PASSWORD=xwiki -e MYSQL_DATABASE=xwiki -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin --explicit-defaults-for-timestamp=1 --default-authentication-plugin=mysql_native_password
If you want to use
utf8instead of
utf8mb4(you won't have emojis though), you could use instead:
character-set-server=utf8 --collation-server=utf8_bin.
The
explicit-defaults-for-timestampparameter was introduced in MySQL 5.6.6 and will thus work only for that version and beyond. If you are using an older MySQL version, please use the following instead:
docker run --net=xwiki-nw --name mysql-xwiki -v /my/path/mysql:/var/lib/mysql -v /my/path/mysql-init:/docker-entrypoint-initdb.d -e MYSQL_ROOT_PASSWORD=xwiki -e MYSQL_USER=xwiki -e MYSQL_PASSWORD=xwiki -e MYSQL_DATABASE=xwiki -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin
This is exactly similar to starting MySQL and you should thus follow exactly the same steps as for MySQL. The only thing to change is the docker image for MariaDB: instead of
mysql:, use
mariadb:. For example:
mariadb:10.3.
Full command example:
docker run --net=xwiki-nw --name mysql-xwiki -v /my/path/mysql:/var/lib/mysql -v /my/path/mysql-init:/docker-entrypoint-initdb.d -e MYSQL_ROOT_PASSWORD=xwiki -e MYSQL_USER=xwiki -e MYSQL_PASSWORD=xwiki -e MYSQL_DATABASE=xwiki -d mariadb:10.3 --character-set-server=utf8mb4 --collation-server=utf8mb4_bin --explicit-defaults-for-timestamp=1
We will bind mount a local directory to be used by the PostgreSQL container to contain the data put by XWiki inside the database, so that when you stop and restart PostgreSQL you don't find yourself without any data. For example:
/my/path/postgres
You need to make sure this directory exists, before proceeding.
Note Make sure the directory you specify is specified with the fully-qualified path, not a relative path.
docker run --net=xwiki-nw --name postgres-xwiki -v /my/path/postgres:/var/lib/postgresql/data -e POSTGRES_ROOT_PASSWORD=xwiki -e POSTGRES_USER=xwiki -e POSTGRES_PASSWORD=xwiki -e POSTGRES_DB=xwiki -e POSTGRES_INITDB_ARGS="--encoding=UTF8" -d postgres:9.5
You should adapt the command line to use the passwords that you wish for the PostgreSQL root password and for the xwiki user password.
We will also bind mount a local directory for the XWiki permanent directory (contains application config and state), for example:
/my/path/xwiki
Note Make sure the directory you specify is specified with the fully-qualified path, not a relative path.
Ensure this directory exists, and then run XWiki in a container by issuing one of the following command.
For MySQL:
docker run --net=xwiki-nw --name xwiki -p 8080:8080 -v /my/path/xwiki:/usr/local/xwiki -e DB_USER=xwiki -e DB_PASSWORD=xwiki -e DB_DATABASE=xwiki -e DB_HOST=mysql-xwiki xwiki:lts-mysql-tomcat
For PostgreSQL:
docker run --net=xwiki-nw --name xwiki -p 8080:8080 -v /my/path/xwiki:/usr/local/xwiki -e DB_USER=xwiki -e DB_PASSWORD=xwiki -e DB_DATABASE=xwiki -e DB_HOST=postgres-xwiki xwiki:lts-postgres-tomcat
Be careful to use the same DB username, password and database names that you've used on the first command to start the DB container. Also, please don't forget to add a
-e DB_HOST=environment variable with the name of the previously created DB container so that XWiki knows where its database is.
At this point, XWiki should start in interactive blocking mode, allowing you to see logs in the console. Should you wish to run it in "detached mode", just add a "-d" flag in the previous command.
docker run -d --net=xwiki-nw ...
Another solution is to use the Docker Compose files we provide.
wget https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/12/mysql-tomcat/mysql/xwiki.cnf: This will download the MySQL configuration (UTF8, etc)
wgetor prefer to use
curl:
curl -fSL https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/12/mysql-tomcat/mysql/xwiki.cnf -o xwiki.cnf
wget https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/12/mysql-tomcat/mysql/init.sql: This will download some SQL to execute at startup for MySQL
wgetor prefer to use
curl:
curl -fSL https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/12/mysql-tomcat/mysql/init.sql -o init.sql
wget -O docker-compose.yml https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/docker-compose-mysql.yml
wgetor prefer to use
curl:
curl -fSL https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/docker-compose-mysql.yml -o docker-compose.yml
docker-compose up
For reference here's a minimal Docker Compose file using MySQL that you could use as an example (full example here):
version: '2' networks: bridge: driver: bridge services: web: image: "xwiki:lts-mysql-tomcat" container_name: xwiki-mysql-tomcat-web depends_on: - db ports: - "8080:8080" environment: - DB_USER=xwiki - DB_PASSWORD=xwiki - DB_HOST=xwiki-mysql-db volumes: - xwiki-data:/usr/local/xwiki networks: - bridge db: image: "mysql:5.7" container_name: xwiki-mysql-db volumes: - ./xwiki.cnf:/etc/mysql/conf.d/xwiki.cnf - mysql-data:/var/lib/mysql - ./init.sql:/docker-entrypoint-initdb.d/init.sql environment: - MYSQL_ROOT_PASSWORD=xwiki - MYSQL_USER=xwiki - MYSQL_PASSWORD=xwiki - MYSQL_DATABASE=xwiki networks: - bridge volumes: mysql-data: {} xwiki-data: {}
wget -O docker-compose.yml https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/docker-compose-postgres.yml
wgetor prefer to use
curl:
curl -fSL https://raw.githubusercontent.com/xwiki-contrib/docker-xwiki/master/docker-compose-postgres.yml -o docker-compose.yml
docker-compose up
For reference here's a minimal Docker Compose file using PostgreSQL that you could use as an example (full example here):
version: '2' networks: bridge: driver: bridge services: web: image: "xwiki:lts-postgres-tomcat" container_name: xwiki-postgres-tomcat-web depends_on: - db ports: - "8080:8080" environment: - DB_USER=xwiki - DB_PASSWORD=xwiki - DB_HOST=xwiki-postgres-db volumes: - xwiki-data:/usr/local/xwiki networks: - bridge db: image: "postgres:9.5" container_name: xwiki-postgres-db volumes: - postgres-data:/var/lib/postgresql/data environment: - POSTGRES_ROOT_PASSWORD=xwiki - POSTGRES_PASSWORD=xwiki - POSTGRES_USER=xwiki - POSTGRES_DB=xwiki - POSTGRES_INITDB_ARGS="--encoding=UTF8" networks: - bridge volumes: postgres-data: {} xwiki-data: {}
Here are some examples of using this image with Docker Swarm. These examples leverage additional features of Docker Swarm such as Docker secrets, and Docker configs. As such, these examples require Docker to be in swarm mode.
You can read more about these features and Docker swarm mode here:
This example presupposes the existence of the Docker secrets
xwiki-db-username,
xwiki-db-passwordand
xwiki-db-root-password, and the Docker config
xwiki-mysql-config.
You can create these secrets and configs with the following:
echo ${MY_XWIKI_USER:-xwiki} | docker secret create xwiki-db-username -
echo $(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1) | docker secret create xwiki-db-password -
echo $(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1) | docker secret create xwiki-db-root-password -
docker config create xwiki-mysql-config /path/to/mysql/xwiki.cnf
To deploy this example, save the following YAML as
xwiki-stack.yaml, then run:
docker stack deploy -c xwiki-stack.yaml xwiki
version: '3.3' services: web: image: "xwiki:lts-mysql-tomcat" ports: - "8080:8080" environment: - DB_USER_FILE=/run/secrets/xwiki-db-username - DB_PASSWORD_FILE=/run/secrets/xwiki-db-password - DB_DATABASE=xwiki - DB_HOST=db volumes: - xwiki-data:/usr/local/xwiki secrets: - xwiki-db-username - xwiki-db-password db: image: "mysql:5.7" volumes: - mysql-data:/var/lib/mysql environment: - MYSQL_ROOT_PASSWORD_FILE=/run/secrets/xwiki-db-root-password - MYSQL_USER_FILE=/run/secrets/xwiki-db-username - MYSQL_PASSWORD_FILE=/run/secrets/xwiki-db-password - MYSQL_DATABASE=xwiki secrets: - xwiki-db-username - xwiki-db-password - xwiki-db-root-password configs: - source: mysql-config target: /etc/mysql/conf.d/xwiki.cnf volumes: mysql-data: xwiki-data: secrets: xwiki-db-username: external: name: xwiki-db-username xwiki-db-password: external: name: xwiki-db-password xwiki-db-root-password: external: name: xwiki-db-root-password configs: mysql-config: external: name: xwiki-mysql-config
This example presupposes the existence of the Docker secrets
xwiki-db-username,
xwiki-db-password, and
xwiki-db-root-password.
You can create these secrets with the following:
echo ${MY_XWIKI_USER:-xwiki} | docker secret create xwiki-db-username -
echo $(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1) | docker secret create xwiki-db-password -
echo $(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1) | docker secret create xwiki-db-root-password -
To deploy this example, save the following YAML as
xwiki-stack.yamlthen run:
docker stack deploy -c xwiki-stack.yaml xwiki
version: '3.3' services: web: image: "xwiki:lts-postgres-tomcat" ports: - "8080:8080" environment: - DB_USER_FILE=/run/secrets/xwiki-db-username - DB_PASSWORD_FILE=/run/secrets/xwiki-db-password - DB_DATABASE=xwiki - DB_HOST=db volumes: - xwiki-data:/usr/local/xwiki secrets: - xwiki-db-username - xwiki-db-password db: image: "postgres:9.5" volumes: - postgres-data:/var/lib/postgresql/data environment: - POSTGRES_ROOT_PASSWORD_FILE=/run/secrets/xwiki-db-root-password - POSTGRES_USER_FILE=/run/secrets/xwiki-db-username - POSTGRES_PASSWORD_FILE=/run/secrets/xwiki-db-password - POSTGRES_DB=xwiki secrets: - xwiki-db-username - xwiki-db-password - xwiki-db-root-password volumes: postgres-data: xwiki-data: secrets: xwiki-db-username: external: name: xwiki-db-username xwiki-db-password: external: name: xwiki-db-password xwiki-db-root-password: external: name: xwiki-db-root-password
From the XWiki Solr Search API documentation:
By default XWiki ships with an embedded Solr. This is mostly for ease of use but the embedded instance is not really recommended by the Solr team so you might want to externalize it when starting to have a wiki with a lots of pages. Solr is using a lot of memory and a standalone Solr instance is generally better in term of speed than the embedded one. It should not be much noticeable in a small wiki but if you find yourself starting to have memory issues and slow search results you should probably try to install and setup an external instance of Solr using the guide.
Also the speed of the drive where the Solr index is located can be very important because Solr/Lucene is quite filesystem intensive. For example putting it in a SSD might give a noticeable boost.
You can also find more Solr-specific performance details on https://wiki.apache.org/solr/SolrPerformanceProblems. Standalone Solr also comes with a very nice UI, along with monitoring and test tools.
This image provides the configuration parameters
INDEX_HOSTand
INDEX_PORTwhich are used to configure
xwiki.propertieswith:
solr.type=remote solr.remote.url=http://$INDEX_HOST:$INDEX_PORT/solr/xwiki
The simplest way to create an external Solr service is using the official Solr image.
solr-init.shthat you can fetch from the docker-xwiki repository
chown -R 8983:8983 /path/to/solr/init/directory
/docker-entrypoint-initdb.d
solr-init.shon container startup and prepare the XWiki core with the contents from the given JAR
chown 8983:8983 /my/path/solr
Start your chosen database container normally using the docker run command above, this example happens to assume MySQL was chosen.
The command below will configure the Solr container to initialize based on the contents of
/path/to/solr/init/directory/and save its data on the host in a
/my/path/solrdirectory:
docker run \ --net=xwiki-nw \ --name solr-xwiki \ -v /path/to/solr/init/directory:/docker-entrypoint-initdb.d \ -v /my/path/solr:/opt/solr/server/solr/xwiki \ -d solr:7.2
Then start the XWiki container, the below command is nearly identical to that specified in the Starting XWiki section above, except that it includes the
-e INDEX_HOST=environment variable which specifies the hostname of the Solr container.
docker run \ --net=xwiki-nw \ --name xwiki \ -p 8080:8080 \ -v /my/path/xwiki:/usr/local/xwiki \ -e DB_USER=xwiki \ -e DB_PASSWORD=xwiki \ -e DB_DATABASE=xwiki \ -e DB_HOST=mysql-xwiki \ -e INDEX_HOST=solr-xwiki \ -d xwiki:lts-mysql-tomcat
The below compose file assumes that
./solrcontains
solr-init.shand the configuration JAR file.
version: '2' networks: bridge: driver: bridge services: web: image: "xwiki:lts-mysql-tomcat" container_name: xwiki-web depends_on: - db - index ports: - "8080:8080" environment: - XWIKI_VERSION=xwiki - DB_USER=xwiki - DB_PASSWORD=xwiki - DB_DATABASE=xwiki - DB_HOST=xwiki-db - INDEX_HOST=xwiki-index volumes: - xwiki-data:/usr/local/xwiki networks: - bridge db: image: "mysql:5.7" container_name: xwiki-db volumes: - ./mysql/xwiki.cnf:/etc/mysql/conf.d/xwiki.cnf - mysql-data:/var/lib/mysql environment: - MYSQL_ROOT_PASSWORD=xwiki - MYSQL_USER=xwiki - MYSQL_PASSWORD=xwiki - MYSQL_DATABASE=xwiki networks: - bridge index: image: "solr:7.2" container_name: xwiki-index volumes: - ./solr:/docker-entrypoint-initdb.d - solr-data:/opt/solr/server/solr networks: - bridge volumes: mysql-data: {} xwiki-data: {} solr-data: {}
If you need to configure Tomcat (for example to setup a reverse proxy configuration), you'll need to mount the Tomcat configuration directory (
/usr/local/tomcat/conf) inside the image onto your local host.
If you want to modify the existing configuration rather than provide a brand new one, you'll need to use
docker cpto copy the configuration from the container to your local host.
Here are some example steps you can follow:
docker create.
docker create --name xwiki xwiki:lts-mysql-tomcat.
docker cp.
sudo docker cp xwiki:/usr/local/tomcat/conf /tmp/tomcat.
docker rm xwiki.
docker run --net=xwiki-nw --name xwiki -p 8080:8080 -v /tmp/xwiki:/usr/local/xwiki -v /tmp/tomcat:/usr/local/tomcat/conf -e DB_USER=xwiki -e DB_PASSWORD=xwiki -e DB_DATABASE=xwiki -e DB_HOST=mysql-xwiki xwiki:lts-mysql-tomcat
This allows you to rebuild the XWiki docker image locally. Here are the steps:
git clone https://github.com/xwiki-contrib/docker-xwiki.gitor download the sources from the GitHub UI. Then go to the directory corresponding to the docker tag you wish to use. For example:
cd 8/mysql-tomcat
8/mysql-tomcatdirectory will get you the latest released XWiki version of the 8.x cycle running on Tomcat and for MySQL.
8/postgres-tomcatdirectory will get you the latest released XWiki version of the 8.x cycle running on Tomcat and for MySQL.
9/mysql-tomcatdirectory will get you the latest released XWiki version of the 9.x cycle running on Tomcat and for MySQL.
docker-compose up
http://localhost:8080
Note that if you want to set a custom version of XWiki you can edit the
.envfile and set the values you need in there. It's also possible to override them on the command line with
docker-compose run -e "XWIKI_VERSION=8.4.4".
Note that
docker-compose upwill automatically build the XWiki image on the first run. If you need to rebuild it you can issue
docker-compose up --build. You can also build the image with
docker build . -t xwiki-mysql-tomcat:latestfor example.
You can also just build the image by issuing
docker build -t xwiki .and then use the instructions from above to start XWiki and the database using
docker run ....
You've installed an XWiki docker image and used it and now comes the time when you'd like to upgrade XWiki to a newer version.
If you've followed the instructions above you've mapped the XWiki permanent directory to a local directory on your host.
All you need to do to upgrade is to stop the running XWiki container and start the new version of it that you want to upgrade to. You should keep your DB container running.
Note that your current XWiki configuration files (
xwiki.cfg,
xwiki.propertiesand
hibernate.cfg.xml) will be preserved.
You should always check the Release Notes for all releases that happened between your current version and the new version you're upgrading to, as there could be some manual steps to perform (such as updating your XWiki configuration files).
The first time you create a container out of the xwiki image, a shell script (
/usr/local/bin/docker-entrypoint.sh) is executed in the container to setup some configuration. The following environment variables can be passed:
DB_USER: The user name used by XWiki to read/write to the DB.
DB_PASSWORD: The user password used by XWiki to read/write to the DB.
DB_DATABASE: The name of the XWiki database to use/create.
DB_HOST: The name of the host (or docker container) containing the database. Default is "db".
INDEX_HOST: The hostname of an externally configured Solr instance. Defaults to "localhost", and configures an embedded Solr instance.
INDEX_PORT: The port used by an externally configured Solr instance. Defaults to 8983.
CONTEXT_PATH: The name of the context path under which XWiki will be deployed in Tomcat. If not specified then it'll be deployed as ROOT.
xwiki.cfgfile in your mapped local permanent directory and set
xwiki.webapppath=.
In order to support Docker secrets, these configuration values can also be given to the container as files containing that value.
DB_USER_FILE: The location, inside the container, of a file containing the value for
DB_USER
DB_PASSWORD_FILE: The location, inside the container, of a file containing the value for
DB_PASSWORD
DB_DATABASE_FILE: The location, inside the container, of a file containing the value for
DB_DATABASE
DB_HOST_FILE: The location, inside the container, of a file containing the value for
DB_HOST
INDEX_HOST_FILE: The location, inside the container, of a file containing the value for
INDEX_HOST
INDEX_PORT_FILE: The location, inside the container, of a file containing the value for
INDEX_PORT
Note: For each configuration value, the normal environment variable and _FILE environment variable are mutually exclusive. Providing values for both variables will result in an error.
The main XWiki configuration files (
xwiki.cfg,
xwiki.propertiesand
hibernate.cfg.xml) are available in the mapped local directory for the permanent directory on your host.
If you need to perform some advanced configuration, you can get a shell inside the running XWiki container by issuing the following (but note that these won't be saved if you remove the container):
docker exec -it bash -l
It's possible to pass JVM options to Tomcat by defining the
JAVA_OPTSenvironment property.
For example to debug XWiki, you could use:
docker run --net=xwiki-nw --name xwiki -p 8080:8080 -v xwiki:/usr/local/xwiki -e DB_USER=xwiki -e DB_PASSWORD=xwiki -e DB_DATABASE=xwiki -e DB_HOST=mysql-xwiki -e JAVA_OPTS="-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005" -p 5005:5005 xwiki
Notice the mapping of the port with
p 5005:5005which expose the port and thus allows you to debug XWiki from within your IDE for example.
Volumes:
If you don't map any volume when using
docker runor if you use
docker-composethen Docker will create some internal volumes attached to your containers as follows.
_mysql-dataor
_postgres-datathat contains the database data.
_xwiki-datathat contains XWiki's permanent directory.
To find out where those volumes are located on your local host machine you can inspect them with
docker volume inspect. To find the volume name, you can list all volumes with
docker volume ls.
Note that on Mac OSX, Docker runs inside the xhyve VM and thus the paths you get when inspecting the volumes are relative to this. Thus, you need to get into that VM if you need to access the volume data.
MySQL:
docker ps
docker exec -it bash -l
mysqlcommand:
mysql --user=xwiki --password=xwiki
Upgrade stable version to.
build.gradlefile found in the XWiki Docker repository (clone it locally first).
To know how to generate the sha256, check the doc inside
build.gradle. You need to download in advance the XWiki WAR file and run the according command in order to generate.
On Linux, use the following one-liner and replace the value of the
VERSIONvariable accordingly:
VERSION="9.11.8"; wget http://nexus.xwiki.org/nexus/content/groups/public/org/xwiki/platform/xwiki-platform-distribution-war/${VERSION}/xwiki-platform-distribution-war-${VERSION}.war && sha256sum xwiki-platform-distribution-war-${VERSION}.war && rm xwiki-platform-distribution-war-${VERSION}.war
On Mac, use the following one-liner and replace the value of the
VERSIONvariable accordingly:
VERSION="10.11"; wget http://nexus.xwiki.org/nexus/content/groups/public/org/xwiki/platform/xwiki-platform-distribution-war/${VERSION}/xwiki-platform-distribution-war-${VERSION}.war && shasum --algorithm 256 xwiki-platform-distribution-war-${VERSION}.war && rm xwiki-platform-distribution-war-${VERSION}.war
Execute the Gradle build (run
./gradlew) to generate the various Dockerfiles and other resources for all image tags
Test the docker container
If all is ok commit, push and close the jira issue created above
Note down the SHA1 of the last commit and update the official library file with it by creating a Pull Request (you can edit directly on the GitHub web page and create a Pull Request).
.0version when releasing the first minor version for a given major. For example when releasing version
12.3, also add the
12.3.0tag so that users can refer to this exact version. Otherwise, when releasing
12.3.1, the meaning of the
12.3tag will change and will now mean
12.3.1.
Make sure to update this file if the documentation needs to be updated.
Test the modified files. On Linux, you need to use
sudoon each docker command or configure it differently.
sudo systemctl start docker
docker network create -d bridge xwiki-test
Execute the following command to start a MySQL database (for example):
docker run --net=xwiki-test --name mysql-xwiki-test -v /tmp/xwiki-docker-test/mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=xwiki -e MYSQL_USER=xwiki -e MYSQL_PASSWORD=xwiki -e MYSQL_DATABASE=xwiki -d mysql:5.7 --character-set-server=utf8 --collation-server=utf8_bin --explicit-defaults-for-timestamp=1
Navigate to the directory to test, e.g.
10/mysql-tomcatand issue:
docker build -t xwiki-test .
Start XWiki (using the started MySQL container in this example):
docker run --net=xwiki-test --name xwiki-test -p 8080:8080 -v /tmp/xwiki-docker-test/xwiki:/usr/local/xwiki -e DB_USER=xwiki -e DB_PASSWORD=xwiki -e DB_DATABASE=xwiki -e DB_HOST=mysql-xwiki-test xwiki-test
Note that same as for the MyQSL container above you'll need to remove the container if it already exists. - In case you had an XWiki instance running on 8080 and the above command fails (i.e. address already in use), you cannot simply run it again. If you do (and you should try, actually), will try to recreate the container with the
xwiki-testname that is now already in use by a container for which you are given the ID (note that down). Instead, you need to simply start the mentioned container ID which previously failed by running
docker start. - Open your browser to http://localhost:8080 and try to setup XWiki and verify it works
If all is ok commit, push and close the JIRA issue created above
Execute:
docker stop xwiki-test docker rm xwiki-test docker stop mysql-xwiki-test docker rm mysql-xwiki-test docker network rm xwiki-test docker rmi xwiki-test sudo rm -Rf /tmp/xwiki-docker-test
XWiki is licensed under the LGPL 2.1.
The Dockerfile repository is also licensed under the LGPL 2.1.