====== Installing Avril ======

===== Create new user on the system (optional) =====
If necessary create a new user:
<code bash>
adduser kalaschnikow
</code>

And add this user to the sudoers group:
<code bash>
usermod -aG sudo kalaschnikow
</code>

===== Change SSH configuration (optional) =====
Edit the ''sshd_config'' file:
<code bash>
sudo nano /etc/ssh/sshd_config
</code>

Change following options in it:
<code bash>
Port 1002
PermitRootLogin no
AllowUsers kalaschnikow
</code>

To apply the new settings reload the SSH service:

<code bash>
sudo service ssh reload
</code>


More about SSH hardening: https://major.io/2013/05/14/changing-your-ssh-servers-port-from-the-default-is-it-worth-it/

===== Install Docker CE =====

https://docs.docker.com/install/linux/docker-ce/ubuntu/#install-docker-ce-1

After that install docker-compose: https://docs.docker.com/compose/install/

===== Create all necessary directories =====

After that create directories for our installation:
<code bash>
sudo mkdir -p /dockerdata/avril/upload
sudo mkdir -p /dockerdata/avril/wildfly/upload
sudo mkdir -p /dockerdata/avril/wildfly/deployments
sudo mkdir -p /dockerdata/avrilmysql
sudo mkdir -p /dockerdata/keycloakmysql
sudo mkdir -p /dockerdata/_artifacts
sudo mkdir -p /dockerdata/_projects/Avril
sudo mkdir -p /dockerdata/_projects/AvrilKeycloak
sudo mkdir -p /dockerdata/_projects/AvrilRabbitMQ

# make dirs for volumes (see docker-compose.yml for all volumes):
#
# keycloakmysql service
sudo mkdir -p /dockerdata/volumes/keycloakmysql

# avrilkeycloak service
sudo mkdir -p /dockerdata/volumes/avrilkeycloak

# avrilmysql service
sudo mkdir -p /dockerdata/volumes/avrilmysql

# avril service
sudo mkdir -p /dockerdata/volumes/avril/modules/system/add-ons
sudo mkdir -p /dockerdata/volumes/avril/wildfly/deployments
sudo mkdir -p /dockerdata/volumes/avril/wildfly/standalone/configuration
sudo mkdir -p /dockerdata/volumes/avril/wildfly/standalone/log
sudo mkdir -p /dockerdata/volumes/avril/upload
sudo mkdir -p /dockerdata/volumes/avril/wildfly/upload
sudo mkdir -p /dockerdata/volumes/avril/modules/system/layers/base/com/mysql

# avriljrserver service
sudo mkdir -p /dockerdata/volumes/jrserver/license
sudo mkdir -p /dockerdata/volumes/jrserver/reports

# avrilrabbitmq service
sudo mkdir -p /dockerdata/volumes/avrilrabbitmq/log

# avrilnginx service
sudo mkdir -p /dockerdata/volumes/avrilnginx/logs


</code>

Or all-in-one command -> make all directories (except of volumes):
<code bash>
mkdir /dockerdata && mkdir /dockerdata/avril && mkdir /dockerdata/avril/upload && \
mkdir /dockerdata/avril/wildfly && mkdir /dockerdata/avril/wildfly/upload && mkdir /dockerdata/avril/wildfly/deployments && \
mkdir /dockerdata/avrilmysql && mkdir /dockerdata/keycloakmysql && \
mkdir /dockerdata/_artifacts && mkdir /dockerdata/_projects && mkdir /dockerdata/_projects/Avril && \
mkdir /dockerdata/_projects/AvrilKeycloak && mkdir /dockerdata/_projects/AvrilRabbitMQ
</code>


===== Move MySQL Databases =====

Move databases (zipped previously on the source system) to the new server with:

<code bash>
# on the old server
cd /dockerdata/volumes
sudo zip -r keycloakmysql.zip keycloakmysql
sudo zip -r avrilmysql.zip avrilmysql
# then copy zip files to the target system
scp -P1002 *.zip  kalaschnikow@avril2021.avril.work:/home/kalaschnikow
</code>

After that (on the new server):

<code bash>
mv ~/*.zip  /dockerdata/_artifacts
cd /dockerdata/_artifacts
unzip avrilmysql.zip
unzip keycloakmysql.zip
# move the inflated directories to /dockerdata/volumes
mv avrilmysql ../volumes
mv keycloakmysql ../volumes
cd ../volumes
chmod -R a+w keycloakmysql
</code>


===== Create user-defined network =====

Create user-defined network ''avrilnet'', in which all our containers will run:

<code bash>
sudo docker network create avrilnet
</code>

===== Create container for keycloak database =====
At first create the container for the keycloak database. The best option is to create it with docker-compose. So simply add the following service to the ''docker-compose.yml'' (see the avril workspace for the latest version!) :
<code>
  keycloakmysql:
    image: mysql:5.5
    environment:
      - MYSQL_DATABASE=keycloak
      - MYSQL_USER=keycloak
      - MYSQL_PASSWORD=keycYaopnlp=8
      - MYSQL_ROOT_PASSWORD=mysqlYaopnlp=8
    ports:
      - "3307:3306"
    volumes:
      - /dockerdata/volumes/keycloakmysql:/var/lib/mysql
    networks:
      default:
        aliases:
          - keycloakmysql
  #
  # To deploy in docker swarm instead of 'restart' use the following:
  #
  #    deploy:
  #      restart_policy:
  #        condition: on-failure
  #        delay: 5s
  #        max_attempts: 3
    restart: on-failure
</code>

Another option is to create the container with ''docker run'':
<code bash>
sudo docker run --network avrilnet -p 3307:3306 \
--name keycloakmysql -v /dockerdata/keycloakmysql:/var/lib/mysql \
-e MYSQL_DATABASE=keycloak -e MYSQL_USER=keycloak -e MYSQL_PASSWORD=keycYaopnlp=8 \
-e MYSQL_ROOT_PASSWORD=mysqlYaopnlp=8 -d mysql:5.5
</code>

===== Create container for keycloak (move it from old server) =====

<code bash>
#
# ### On SRC server ###
#

# pack AvrilKeycloak image
sudo docker save -o ./AvrilKeycloak.tar avrilkeycloak:latest

# copy file to the DEST server
scp AvrilKeycloak.tar -P1002 kalaschnikow@avril2021.avril.work:/home/kalaschnikow


#
# ### On DEST server ###
#

# copy file to _artifacts folder
cd /dockerdata/_artifacts
mv ~/AvrilKeycloak.tar .


# load AvrilKeycloak image
sudo docker load -i AvrilKeycloak.tar

</code>

Then copy ''standalone.xml'' from the old server to the new:
<code bash>
cd /dockerdata/volumes/avrilkeycloak
scp -P1002 stand*  kalaschnikow@avril2021.avril.work:/home/kalaschnikow
# on the new server:
cd /dockerdata/volumes/avrilkeycloak
cp ~/standalone.xml .
</code>

After that start the compose:
<code bash>
cd /dockerdata/compose
sudo docker-compose up -d
</code>

Now we should have two services running: ''avrilkeycloak'' and ''keycloakmysql''.
===== Create a NEW container for keycloak (unfortunately it does not work 100%) =====

**Caution**: it does not work 100%, so at the moment moving the image from the old server would be a better option.

Under ''/dockerdata/_projects/AvrilKeycloak'' create the file ''Dockerfile'' with the following contents:
<code>
FROM jboss/keycloak:latest

COPY standalone.xml /opt/jboss/keycloak/standalone/configuration/
COPY standalone-ha.xml /opt/jboss/keycloak/standalone/configuration/

#USER jboss
#RUN sed -i -e 's/<web-context>auth<\/web-context>/<web-context>keycloak\/auth<\/web-context>/' /opt/jboss/keycloak/standalone/configuration/standalone.xml
#RUN sed -i -e 's/<web-context>auth<\/web-context>/<web-context>keycloak\/auth<\/web-context>/' /opt/jboss/keycloak/standalone/configuration/standalone-ha.xml


CMD ["-b", "0.0.0.0", "-Djboss.socket.binding.port-offset=100"]
</code>

Old content of ''Dockerfile'':

<code>

FROM jboss/keycloak:4.7.0.Final

CMD ["-b", "0.0.0.0", "-Djboss.socket.binding.port-offset=100"]

</code>

Copy ''/mnt/sda4/development/workspaces/AvrilServer/DockerImages/AvrilKeycloak/src/main/resources/standalone.xml'' and ''/mnt/sda4/development/workspaces/AvrilServer/DockerImages/AvrilKeycloak/src/main/resources/standalone-ha.xml'' to ''/dockerdata/_projects/AvrilKeycloak'' on the new server:

<code bash>
cd /mnt/sda4/development/workspaces/AvrilServer/DockerImages/AvrilKeycloak/src/main/resources/
scp -P1002 standalone*.xml  kalaschnikow@avril2021.avril.work:/home/kalaschnikow
# then on the new server:
cd /dockerdata/_projects/AvrilKeycloak
sudo mv ~/Dockerfile .
sudo mv ~/standalone.xml .
sudo mv ~/standalone-ha.xml .
</code>

==== Build the image for keycloak server ====
Build the image for keycloak server:
<code bash>
cd /dockerdata/_projects/AvrilKeycloak
sudo docker image build --tag avrilkeycloak .
</code>


==== Option 1: Create a container for keycloak server with ''docker-compose'' ====

Add following service to ''docker-compose.yml'' (see the avril workspace for the latest version!):
<code>
  avrilkeycloak:
    image: avrilkeycloak
    environment:
      - DB_VENDOR=mysql
      - DB_ADDR=keycloakmysql
      - MYSQL_PORT_3306_TCP_ADDR=keycloakmysql
      - MYSQL_PORT_3306_TCP_PORT=3307
      - MYSQL_PASSWORD=keycYaopnlp=8
      - PROXY_ADDRESS_FORWARDING=true
    ports:
      - "8180:8180"
    volumes:
      - /dockerdata/volumes/avrilkeycloak/standalone.xml:/opt/jboss/keycloak/standalone/configuration/standalone.xml
    depends_on:
      - keycloakmysql
    networks:
      default:
        aliases:
          - avrilkeycloak
    restart: on-failure
</code>

Then copy ''standalone.xml'' from the old server to the new:
<code bash>
cd /dockerdata/volumes/avrilkeycloak
scp -P1002 stand*  kalaschnikow@avril2021.avril.work:/home/kalaschnikow
# on the new server:
cd /dockerdata/volumes/avrilkeycloak
cp ~/standalone.xml .
</code>

After that start the compose:
<code bash>
cd /dockerdata/compose
sudo docker-compose up -d
</code>

Now we should have two services running: ''avrilkeycloak'' and ''keycloakmysql''.

==== Option 2: Create a container for keycloak server with ''docker run'' ====

Create a container for keycloak server and run it:
<code bash>
sudo docker image build --tag avrilkeycloak .

sudo docker run --network avrilnet --name avrilkeycloak -p 8180:8180   -e DB_VENDOR=mysql   -e DB_ADDR=keycloakmysql   -e MYSQL_PORT_3306_TCP_ADDR=keycloakmysql   -e MYSQL_PORT_3306_TCP_PORT=3306   -e MYSQL_PASSWORD=keycYaopnlp=8   -d avrilkeycloak
</code>

Now the containers can be started: ''sudo docker start keycloakmysql && sudo docker start avrilkeycloak'' 

If necessary: open the Keycloak admin console, go to "Clients" and change "Root URL" for:
  * avril-web
  * security-admin-console



===== Create container for nginx =====

At first move all necesary config files from old server to the new

<code bash>
cd /dockerdata/volumes/avrilnginx
scp -P1002 *.conf  kalaschnikow@avril2021.avril.work:/home/kalaschnikow
# then on the new server:
mv ~/*.conf .
</code>

Then open the file ''nginx.conf'' in editor and change all old IPs to the new:
<code>
...
</code>

Also change lines:
<code>
        ssl_certificate             /etc/letsencrypt/live/avril2021.avril.work/fullchain.pem;
        ssl_certificate_key         /etc/letsencrypt/live/avril2021.avril.work/privkey.pem;
        # ssl_trusted_certificate     /etc/letsencrypt/live/avril2021.avril.work/chain.pem;
</code>

==== Get certificates using certbot ====

Get Let's Encrypt certificates using certbot:
<code bash>
sudo certbot certonly --standalone -d avril2021.avril.work --email info@avril.work -n --agree-tos --expand
</code>

(maybe the better way would be to get certificates not with ''--standalone'' option but with ''--nginx'', but I don't really know how to do it)

After that don't forget to renew the certificates before they expire (see [[Avril and Let's Encrypt Certificates]])! So either set an appointment in Google Calendar or (better) troubleshoot the renewing (''sudo certbot renew --dry-run'').


==== Option 1: Create the container with docker-compose ====

The best option is to create it with docker-compose. So simply add the following service to the ''docker-compose.yml'' (see the avril workspace for the latest version!) :
<code>
  avrilnginx:
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
      - "8183:8183"
    volumes:
      - /dockerdata/volumes/avrilnginx/nginx.conf:/etc/nginx/nginx.conf
      - /dockerdata/volumes/avrilnginx/proxy_params.conf:/etc/nginx/proxy_params.conf
      - /etc/letsencrypt/:/etc/letsencrypt/
      - /dockerdata/volumes/avrilnginx/logs/:/var/log/nginx
    restart: on-failure
</code>

==== Option 2: Create the container with docker-run ====
Another option is to create the container with ''docker run'':
<code bash>
# not yet documented...
# something like:
# sudo docker run --network avrilnet -p 3307:3306 \
# --name avrilnginx -v ... -d nginx
</code>

===== Create containers for avril database =====

==== Option 1: Create container with docker-compose ====
Add the following service to the ''/dockerdata/compose/docker-compose.yml'' (see the avril workspace for the latest version!):
<code>
  avrilmysql:
    image: mysql:5.5
    environment:
      - MYSQL_DATABASE=avril
      - MYSQL_USER=avril
      - MYSQL_PASSWORD=avrilYaopnlp=8
      - MYSQL_ROOT_PASSWORD=mysqlYaopnlp=8
    ports:
      - "3306:3306"
    volumes:
      - /dockerdata/volumes/avrilmysql:/var/lib/mysql
    networks:
      default:
        aliases:
          - avrilmysql
    restart: on-failure
</code>

Then start the compose:
<code bash>
cd /dockerdata/compose

# if necessary at first shutdown the compose
sudo docker-compose down

# then start it
sudo docker-compose up -d
</code>


==== Option 2: Create container with docker run ====

(This way was not tested in august 2021.)

Create and run container for Avril application database
<code bash>
sudo docker run --network avrilnet -p 3306:3306 \
--name avrilmysql -v /dockerdata/avrilmysql:/var/lib/mysql \
-e MYSQL_DATABASE=avril -e MYSQL_USER=avril -e MYSQL_PASSWORD=avrilYaopnlp=8 \
-e MYSQL_ROOT_PASSWORD=mysqlYaopnlp=8 -d mysql:5.5
</code>

===== Create container for avril application =====

Under ''/dockerdata/_projects/Avril'' create the file ''Dockerfile'' with the following contents (see the avril workspace for the latest version):
<code docker>
FROM jboss/wildfly:15.0.0.Final

# no longer necessary because we use a volume to deploy war-files
# ADD AvrilDock-201712-SNAPSHOT.war /opt/jboss/wildfly/standalone/deployments/AvrilDock.war
# ADD AvrilWebAdmin-201712-SNAPSHOT.war /opt/jboss/wildfly/standalone/deployments/AvrilWebAdmin.war


ADD  standalone-custom.xml /opt/jboss/wildfly/standalone/configuration/

EXPOSE 9990

EXPOSE 8787

#RUN /opt/jboss/wildfly/bin/add-user.sh admin masterkey --silent
#CMD ["/opt/jboss/wildfly/bin/standalone.sh", "-b", "0.0.0.0", "-bmanagement", "0.0.0.0"]

CMD ["/opt/jboss/wildfly/bin/standalone.sh", "-c", "standalone-custom.xml", "-b", "0.0.0.0", "-bmanagement", "0.0.0.0", "--debug"]

</code>

Copy the content of the file ''standalone-custom.xml'' from the avril workspace to the ''/dockerdata/_projects/Avril'' (or copy the file from the old system).

<code bash>
scp -P1002 modules.zip standalone-custom.xml kalaschnikow@avril2021.avril.work:/home/kalaschnikow

scp -P1002 *.war modules.zip standalone-custom.xml kalaschnikow@avril2021.avril.work:/home/kalaschnikow

</code>



Then move *.war files to ''/dockerdata/_projects/Avril'':
<code bash>
mv /home/kalaschnikow/Avril*.war /dockerdata/volumes/avril/wildfly/deployments
</code>

Then move ''standalone-custom.xml'' to ''/dockerdata/_projects/Avril'':
<code bash>
sudo mv /home/kalaschnikow/standalone-custom.xml /dockerdata/_projects/Avril
</code>

Move modules.zip to ''/dockerdata/avril'' and unzip it:
<code bash>
sudo mv /home/kalaschnikow/modules.zip /dockerdata/avril

cd /dockerdata/avril

unzip modules.zip
</code>

Move content of directory ''/dockerdata/volumes/avril/modules/system/layers/base/com/mysql/'' from source to destination system:
<code bash>
# on the SRC system
cd /dockerdata/volumes/avril/modules/system/layers/base/com/mysql/jdbc/main
scp -P1002 *.*  kalaschnikow@avril2021.avril.work:/home/kalaschnikow

# on the DEST system
cd /dockerdata/volumes/avril/modules/system/layers/base/com/mysql/jdbc/main
cp ~/module.xml .
cp ~/mysql-connector-java-5.1.31-bin.* .
</code>


After that build and run avril container:
<code bash>
cd /dockerdata/_projects/Avril

sudo docker image build --tag avril .
</code>

==== Option 1: Create the container for avril application with ''docker-compose'' ====

After that add the avril service to the ''/dockerdata/compose/docker-compose.yml'' (for latest version see the avril workspace):

<code>
  avril:
    image: avril
    environment:
      - PROXY_ADDRESS_FORWARDING=true
      - "JAVA_OPTS=-server -Xdebug -Xms64m -Xmx512m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m -Djava.net.preferIPv4Stack=true -Djboss.modules.system.pkgs=org.jboss.byteman -Djava.awt.headless=true -agentlib:jdwp=transport=dt_socket,address=*:8787,server=y,suspend=n --add-exports=java.base/sun.nio.ch=ALL-UNNAMED --add-exports=jdk.unsupported/sun.misc=ALL-UNNAMED --add-exports=jdk.unsupported/sun.reflect=ALL-UNNAMED --add-modules=java.se"
    ports:
      - "8080:8080"
      - "8787:8787"
      - "9990:9990"
    volumes:
      - /dockerdata/volumes/avril/modules/system/add-ons:/opt/jboss/wildfly/modules/system/add-ons
      - /dockerdata/volumes/avril/wildfly/deployments:/opt/jboss/wildfly/standalone/deployments
      - /dockerdata/volumes/avril/wildfly/standalone/configuration/standalone-custom.xml:/opt/jboss/wildfly/standalone/configuration/standalone-custom.xml
      - /dockerdata/volumes/avril/upload:/opt/avril/upload
      - /dockerdata/volumes/avril/wildfly/upload:/opt/jboss/wildfly/upload
      - /dockerdata/volumes/avril/modules/system/layers/base/com/mysql:/opt/jboss/wildfly/modules/system/layers/base/com/mysql
    depends_on:
      - avrilmysql
      - avrilkeycloak
    networks:
      default:
        aliases:
          - avril
    restart: on-failure
</code>

Then restart the compose:

<code bash>
cd /dockerdata/compose
sudo docker-compose down
sudo docker-compose up -d
</code>

==== Option 2: Create the container for avril application with ''docker run'' ====

It is also possible to run the container with ''docker run'', but it was not tested during the installation in august 2021:
<code bash>
sudo docker run --network avrilnet --name avril --restart unless-stopped \
  -p 8080:8080 -p 9990:9990 -p 8787:8787 \
  -v /dockerdata/avril/modules/system/add-ons:/opt/jboss/wildfly/modules/system/add-ons \
  -v /dockerdata/avril/wildfly/deployments:/opt/jboss/wildfly/standalone/deployments \
  -v /dockerdata/avril/upload:/opt/avril/upload \
  -v /dockerdata/avril/wildfly/upload:/opt/jboss/wildfly/upload \
  -v /dockerdata/avril/modules/system/layers/base/com/mysql:/opt/jboss/wildfly/modules/system/layers/base/com/mysql \
  -it avril
</code>

==== Test Avril installation ====


To test the Avril installation open the following URL in browser: 
<code>http://<your_server>:8080/avril</code>

If troubleshooting will be necessary, ''docker logs <container_name>''  can be used. E.g.:
<code bash>
sudo docker logs compose_avril_1
</code>

For more information about wildfly logs in docker see [[https://goldmann.pl/blog/2014/07/18/logging-with-the-wildfly-docker-image/|Logging with the WildFly Docker image]].


===== Create container for rabbitmq image =====

In ''/dockerdata/_projects/AvrilRabbitMQ'' create a new file ''definitions.json'' with following content (see avril workspace for the latest version):
<code javascript>
{
  "rabbit_version": "3.7.7",
  "users": [
    {
      "name": "guest",
      "password_hash": "bsrunkbbhUNvyz/TvpC9OHn8EXXjDjJLJq8SUW1glZBDp4tx",
      "hashing_algorithm": "rabbit_password_hashing_sha256",
      "tags": "administrator"
    },
    {
      "name": "avril",
      "password_hash": "C+PuHIUxvARVdh3iMcrla9H/QULl27va/Z4lF4yGJYqVg5bN",
      "hashing_algorithm": "rabbit_password_hashing_sha256",
      "tags": ""
    }
  ],
  "vhosts": [
    {
      "name": "/"
    }
  ],
  "permissions": [
    {
      "user": "guest",
      "vhost": "/",
      "configure": ".*",
      "write": ".*",
      "read": ".*"
    },
    {
      "user": "avril",
      "vhost": "/",
      "configure": ".*",
      "write": ".*",
      "read": ".*"
    }
  ],
  "topic_permissions": [
    {
     "user": "avril",
      "vhost": "/",
      "exchange": "",
      "write": ".*",
      "read": ".*"
    }
  ],
  "parameters": [],
  "global_parameters": [
    {
     "name": "cluster_name",
      "value": "rabbit@kalaschnikow2017"
    }
  ],
  "policies": [],
  "queues": [
    {
      "name": "mqtt-subscription-123qos1",
      "vhost": "/",
      "durable": true,
      "auto_delete": false,
      "arguments": {
        "x-expires": 86400000
      }
    }
  ],
  "exchanges": [],
  "bindings": []
}

</code>


In ''/dockerdata/_projects/AvrilRabbitMQ'' create a new file ''Dockerfile'' with following content:
<code>
FROM rabbitmq:3.7.7-management

ADD definitions.json /etc/rabbitmq/
#ADD rabbitmq.config /etc/rabbitmq/
#RUN chown rabbitmq:rabbitmq /etc/rabbitmq/rabbitmq.config /etc/rabbitmq/definitions.json
RUN chown rabbitmq:rabbitmq /etc/rabbitmq/definitions.json

# RUN rabbitmq-plugins enable --offline rabbitmq_management
RUN rabbitmq-plugins enable --offline rabbitmq_mqtt

EXPOSE 1883 15672

CMD ["rabbitmq-server"]
</code>


Now build a new image:
<code bash>
cd /dockerdata/_projects/AvrilRabbitMQ
 
sudo docker image build --tag avrilrabbitmq .
</code>

==== Option 1: start the container with docker-compose ====
Add the following code to the ''/dockerdata/compose/docker-compose.yml'' (see avril workspace for the latest version):
<code>
  avrilrabbitmq:
    image: avrilrabbitmq
    environment:
      - ConnectionString=Server=sql.data;Initial Catalog=CatalogData;User Id=sa;Password=your@password
    expose:
      - "80"
    ports:
      - "1883:1883"
      - "15672:15672"
    volumes:
      - /dockerdata/volumes/avrilrabbitmq/log:/var/log/rabbitmq/log
    networks:
      default:
        aliases:
          - avrilrabbitmq
    restart: on-failure
</code>

Then restart the compose:

<code bash>
cd /dockerdata/compose
sudo docker-compose down
sudo docker-compose up -d
</code>

==== Option 2: start the container with docker run ====

The container can be run with (this option is not tested on ''avril2021'' server):
<code bash>
sudo docker run --network avrilnet \
-d --hostname avril2021.avril.work --name avrilrabbitmq \
-p 15672:15672 -p 1883:1883 \
avrilrabbitmq
</code>
Using IP for hostname (like ''--hostname 185.162.250.65'') is wrong and won't work!


===== Create container for jrserver application =====



==== Create jrserver image ====

(This description is unfortunately not complete. Some copies etc. are not yet described.)

From the local computer:
<code bash>
# cd to the install dir, where are all files
cd ~/Desktop/install_jrserver

# copy build.jar
scp -P1002 ./build*.jar  kalaschnikow@avril2021.avril.work:/home/kalaschnikow

# if necessary copy the report(s) too
scp -P1002 ./*.jrxml  kalaschnikow@avril2021.avril.work:/home/kalaschnikow
</code>

On the server:
<code bash>
cp ~/build.jar /dockerdata/jrserver/src/build.jar
cd /dockerdata/jrserver/

# make script executable
sudo chmod a+x builddockerimage.sh

# start script which will create our jrserver image(s)
sudo ./builddockerimage.sh


# copy reports to the volume
cd /dockerdata/volumes/jrserver/reports
cp ~/*.jrxml . 

</code>



==== Option 1: start the container with docker-compose ====
Add the following code to the ''/dockerdata/compose/docker-compose.yml'' (see avril workspace for the latest version):
<code>
  avriljrserver:
    image: jrserver/jrserver-server
#    environment:
#      - PROXY_ADDRESS_FORWARDING=true
#      - "JAVA_OPTS=-server -Xdebug -Xms64m -Xmx512m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m -Djava.net.preferIPv4Stack=true -Djboss.modules.system.pkgs=org.jboss.byteman -Djava.awt.headless=true -agentlib:jdwp=transport=dt_socket,address=*:8787,server=y,suspend=n --add-exports=java.base/sun.nio.ch=ALL-UNNAMED --add-exports=jdk.unsupported/sun.misc=ALL-UNNAMED --add-exports=jdk.unsupported/sun.reflect=ALL-UNNAMED --add-modules=java.se"
    ports:
      - "8380:8080"
    volumes:
      - /dockerdata/volumes/jrserver/license:/src/license
      - /dockerdata/volumes/jrserver/reports:/src/reports
    depends_on:
      - avrilmysql
      - avrilkeycloak
    networks:
      default:
        aliases:
          - avriljrserver
    restart: on-failure
</code>

Then restart the compose:

<code bash>
cd /dockerdata/compose
sudo docker-compose down
sudo docker-compose up -d
</code>
==== Option 2: start the container with docker run ====

The container can be run with (this option is **not tested** on ''avril2021'' server):
<code bash>
sudo docker run --network avrilnet \
-d --hostname avril2021.avril.work --name avriljrserver \
-p 8380:8380 \
avriljrserver
</code>






----

----

----



===== Create autostarting service for all containers =====



...


===== Start all containers with docker compose=====

<code bash>
sudo mkdir /dockerdata/compose
chmod -R a+w /dockerdata/compose
cd /dockerdata/compose

nano docker-compose.yml
</code>

Paste the content of ''docker-compose.yml'' from the avril workspace (on my machine: ''/mnt/sda4/development/workspaces/AvrilServer/DockerImages/docker-compose.yml'') to nano and save it.

After that run the compose:

<code bash>
sudo docker-compose -f /dockerdata/compose/docker-compose.yml up -d

# OR in the directory where docker-compose.yml is:
sudo docker-compose up -d

# OR for debugging purposes in "undetached" mode
sudo docker-compose up
</code>


===== Install Certbot and Let's Encrypt Certificates =====
...