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 "$@"

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.