Uruchomienie JIRA Software w Dockerze

Jako że jestem wielbicielem kontenerków, pamiętam jeszcze dzieciakiem miałem styczność z kontenerami na moim starym Siemens A55 albo Siemens A60 – nie pamiętam już ?; postanowiłem sobie przenieść swą instancję JIRA Software z dedykowanego EC2 hosta do dockera.

Zacznijmy od tego że potrzebujemy Oracle JRE do uruchomienia tego wspaniałego oprogramowania, a jak wiadomo Oracle lubi utrudniać życie innym przez wprowadzenie zakazu dystrubucji JRE – chodzi o to że nie można zrobić skrypt który automatycznie pobierze i zainstaluje JRE w kontenerze, ale można bez problemu wejść na stronę Oracle i ściągnąć JDK nie naruszając licencji. Chodzą plotki, że JIRA już wpiera OpenJDK – ale oficjalnie od wersji 7.13, natomiast ja posiadam licencję na wersję ciut starszą – 7.12, niestety ?

Krok 1. Zbudowanie obrazu kontenera z Oracle JDK

Jest to dość łatwe zadanie, wystarczy wejść na stronę Oracle do pobrania JDK – klik, zaakceptować warunki licencji i ściągnąć wersję dla serwera zapakowane w .tar.gz, np. server-jre-8u192-linux-x64.tar.gz

Dalej już mamy z górki – Oracle przygotował Dockerfile do stworzenia obrazu z JDK – klik. Umieszczamy ten Dockerfile oraz ściągnięty archiwum z JDK obok siebie i uruchamiamy budowanie obrazu:

docker build -t oracle/serverjre:8 .

Nie zbyt skomplikowane, ale niestety nie da się w legalny sposób tego zautomatyzować.

Krok 2. Zbudowanie obrazu kontenera z JIRA Software

Instalacja samej JIRA’y w dockerze jest dość prosta – wystarczy ściągnąć archiwum z oficjalnej strony, rozpakować do folderu, wrzucić konfigurację i uruchomić w trybie „foreground”:

FROM oracle/serverjre:8

ENV JIRA_HOME /var/atlassian/jira
ENV JIRA_INSTALL /opt/atlassian/jira
ENV JIRA_VERSION 7.12.1

RUN set -x \
&& yum install -y tar gzip \
&& mkdir -p "${JIRA_HOME}" \
&& mkdir -p "${JIRA_INSTALL}" \
&& curl -Ls "https://product-downloads.atlassian.com/software/jira/downloads/atlassian-jira-software-${JIRA_VERSION}.tar.gz" | tar -xz --directory "${JIRA_INSTALL}" --strip-components=1 --no-same-owner \
&& echo -e "\njira.home=$JIRA_HOME" >> "${JIRA_INSTALL}/atlassian-jira/WEB-INF/classes/jira-application.properties"

VOLUME [ "${JIRA_HOME}" ]

COPY ./configs/server.xml "${JIRA_INSTALL}/conf/server.xml"

EXPOSE 8080

WORKDIR /opt/atlassian/jira

CMD [ "/opt/atlassian/jira/bin/start-jira.sh", "-fg" ]

Krok 3. Budujemy kontener z bazą danych

Ta instalacja JIRA’y, którą przenoszę do kontenera, korzysta z bazy danych PostgreSQL. Chwała spółeczności open-source, która już stworzyła obraz kontenera tego wspaniałego silnika gotowego do prodakszyna (slang programistyczny, ang. production). Ale niestety musimy troszeczkę zmodyfikować ten obraz, a mianowicie dodać skrypty inicializującę bazę:

Dockerfile

FROM postgres:9.3-alpine

VOLUME [ "/var/lib/postgresql/data" ]

COPY ./init.sh /docker-entrypoint-initdb.d/init.sh

init.sh

#!/bin/bash

set -o errexit

readonly REQUIRED_ENV_VARS=(
"JIRA_DB_USER"
"JIRA_DB_PASSWORD"
"JIRA_DB_NAME"
"POSTGRES_USER")

main() {
check_env_vars_set
init_user_and_db
}

check_env_vars_set() {
for required_env_var in ${REQUIRED_ENV_VARS[@]}; do
if [[ -z "${!required_env_var}" ]]; then
echo "Error:
Environment variable '$required_env_var' not set.
Make sure you have the following environment variables set:
${REQUIRED_ENV_VARS[@]}
Aborting."
exit 1
fi
done
}

init_user_and_db() {
psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" <<-EOSQL
CREATE USER $JIRA_DB_USER WITH PASSWORD '$JIRA_DB_PASSWORD';
CREATE DATABASE $JIRA_DB_NAME WITH ENCODING 'UNICODE' LC_COLLATE 'C' LC_CTYPE 'C' TEMPLATE template0;
GRANT ALL PRIVILEGES ON DATABASE $JIRA_DB_NAME TO $JIRA_DB_USER;
EOSQL
}

main "[email protected]"

Podając kilka zmiennych środowiskowych podczas startu kontenera dostaniemy gotowy do użycia kontener PostgreSQL z zainicjalizowaną bazą danych dla naszej instancji JIRA’y.

Krok 4. Spinamy wszystko korzystając z docker-compose

Teraz możemy spiąć wszystko za pomocą docker-compose i uruchomić na naszej maszynie z dockerem (lokalnej bądź na instancji EC2, na przykład):

version: "3.3"

services:
jira:
build: ./jira-software
image: "vchyzhevskyi/jirasoftware"
container_name: "jirasoftware"
ports:
- "8080:8080"
depends_on:
- "jre"
- "postgresql"
links:
- "postgresql"
volumes:
- type: volume
source: "jira-home"
target: /var/atlassian/jira

jre:
build: ./jre
image: oracle/serverjre:8

postgresql:
build: ./postgresql
image: "vchyzhevskyi/jirasoftware-db"
container_name: "jirasoftware-db"
restart: "always"
env_file:
- ./postgresql/.env
environment:
- "JIRA_DB_USER=jiradbuser"
- "JIRA_DB_NAME=jiradb"
expose:
- "5432"
volumes:
- type: volume
source: "postgresql-data"
target: /var/lib/postgresql/data

volumes:
"postgresql-data":
external: true
"jira-home":
external: true

Do przechowywać kredenszyali (slang programistyczny, ang. credentials) polecam wykorzystać pliki środowiskoweg (env files) korzystając z konfiguracji w docker-compose.yml pod nazwą env_file.

Osobno stworzyłem dwa dockera volume do przechowywania plików naszej instancji bazy danych oraz różnych plików pomocniczych, tj. załączniki, indeksów itd, naszej instancji JIRA Software:

docker volume create postgresql-data

docker volume create --driver local --opt type=none --opt device=$(pwd)/jira-software/jira-home --opt o=bind jira-home

Na przykładzie wyżej stworzyłem docker volume i zbindowałem go odrazu do lokalnego folderu, ale można zrobić to jak w przypadku z volume dla danych PostgreSQL.

Krok 5. Konfiguracja i wypieszczenie instancji do potrzeb organizacji

Po uruchomieniu i konfiguracji połączenia do bazy danych możemy przejść do konfiguracji tego wspaniałego oprogramowania na potrzeby organizacji – na całe szczęście ja miałem za zadanie tylko przenieść już zainstalowaną i skonfigurowaną instancję z dedykowanej instancji EC2, więc zostawiam Was samych w tym momencie.

Ja mówią ludzie na youtube – laikujemy i subskrybujemy! ?