Jak wdrożyć serwer Play za pomocą Docker Compose i Postgres

Jednym z najprostszych sposobów na wdrożenie całkiem sporej ilości aplikacji jest użycie Docker Container. Istnieje mnóstwo witryn hostingowych, które oferują hosting kontenerów, lub możesz zdecydować się na samodzielne hostowanie usługi za pomocą serwera dedykowanego lub VPS. Ręczne utrzymanie kilku różnych kontenerów docker ze zmiennymi środowiskowymi, zmapowanymi portami i woluminami może być dość uciążliwe. Tutaj z pomocą przychodzi Docker Compose.

Docker Compose

Jak podaje dokumentacja Dockera:

Compose to narzędzie do definiowania i uruchamiania wielokontenerowych aplikacji Docker.

Oznacza to, że będziemy mogli w łatwy sposób tworzyć, uruchamiać i zarządzać wieloma skonteneryzowanymi aplikacjami. Na potrzeby tego artykułu stworzymy dwie usługi: serwer backendowy PlayFramework oraz bazę danych PostgreSQL. Jeśli potrzebujesz hostować jakąś aplikację frontendową lub jakiś panel administracyjny możesz dodać więcej usług do pliku docker-compose.

Serwis baz danych – PostgreSQL

Pierwszą rzeczą, którą będziemy musieli zrobić jest stworzenie pliku docker-compose.yml. Po tym możemy przystąpić do konfiguracji. Pierwszą rzeczą, którą musimy dodać jest element najwyższego poziomu: services w pierwszej linii naszego pliku. Pierwszą usługą, którą stworzymy będzie nasza baza danych. Do tego celu użyjemy obrazu PostgreSQL. Usługa będzie się nazywać db. Upewnij się, że twoja usługa jest o jedno tiret głębiej niż element services, a wszystkie inne elementy mają taką samą liczbę tiretów, jak w przykładzie poniżej.

db:
    image: postgres
    container_name: db
    restart: always
    ports:
        - "5432:5432"
    volumes:
        - ./docker/volumes/db:/var/lib/postgresql/data
    environment:
        - POSTGRES_USER=user
        - POSTGRES_PASSWORD=password
        - POSTGRES_DB=database-name 

Let’s explain this configuration:

• db: – nazwa usługi
• image: postgres – określa obraz, którego chcemy użyć. W tym przypadku jest to postgres.
• container_name: db – nazwa kontenera, który zostanie utworzony
• restart: always – ustawia politykę restartu dla kontenera
• ports – mapuje porty kontenera na porty maszyny głównej
• volumes – tworzy wolumen Docker, aby przechowywać dane bazy danych na maszynie głównej
• environment – ustawia zmienne środowiskowe kontenera. Obraz PostgreSQL pozwala nam na utworzenie użytkownika i bazy danych podczas inicjalizacji kontenera poprzez ustawienie zmiennych środowiskowych.

Usługa aplikacji serwera PlayFramework

Następną usługą, którą będziemy potrzebować jest nasz serwer backendu Play. Do tego celu użyjemy obrazu aplikacji Play. Jeśli nie wiesz jak go stworzyć, możesz sprawdzić ten artykuł. Nazwiemy tę usługę play.

play:
    image: your-apps-name:latest
    container_name: your-apps-name
    restart: always
    ports:
        - "9000:9000"
    volumes:
        - ./conf:/opt/docker/conf
        - ./docker/volumes/play/files:/opt/docker/your-app-name_files
        - ./docker/volumes/play/logs:/opt/docker/logs
    environment:
        - POSTGRES_USER=user
        - POSTGRES_PASSWORD=password
        - POSTGRES_DB=database-name
    depends_on:
        - db 

W tym serwisie mamy jeden nowy element: depends_on. Dzięki temu nasza aplikacja do zabawy będzie się uruchamiać po db, wktóry jest naszym kontenerem bazy danych. Jeśli nie wiesz dlaczego coś jest ustawione tak jak jest w tej usłudze, to prawdopodobnie znajdziesz odpowiedź w tym artykule, w którym pokazujemy jak stworzyć obraz serwera Play.

Ponieważ używamy zmiennych środowiskowych do przekazania poświadczeń bazy danych i nazwy do naszego kontenera serwera Play, musimy zmienić plik konfiguracyjny Play, aby użyć tych zmiennych.

 default.driver = "org.postgresql.Driver"
default.url = "jdbc:postgresql://db:5432/"${?POSTGRES_DB}
default.username = ${?POSTGRES_USER}
default.password = ${?POSTGRES_PASSWORD} 

Powyższa konfiguracja bazy danych umieści określone zmienne w określonych miejscach. Po pierwsze, ponieważ używamy bazy PostgreSQL musimy ustawić odpowiedni sterownik. Następnie w adresie url chcemy połączyć się z bazą danych hostowaną przez serwis db na porcie 5432. Możemy po prostu użyć nazwy naszej usługi z określonym portem jako części naszego adresu url. Następnie umieszczając ${?POSTGRES_DB} dołączymy nazwę bazy danych ze zmiennej środowiskowej do adresu url "jdbc:postgresql://db:5432/". Nazwę użytkownika i hasło do bazy danych ustawimy w ten sam sposób – za pomocą ${?VARIABLE_NAME}.

Environment Variables

Jak możesz zauważyć, musieliśmy zduplikować referencje Możemy to uprościć, używając zmiennych środowiskowych w naszym pliku docker-compose.yml. W tym celu stworzymy plik .env w tym samym katalogu co poprzedni plik. Powinien on wyglądać tak:

POSTGRES_USER=user

POSTGRES_PASSWORD=password

POSTGRES_DB=database-name

APP_NAME=play-app-server

 

Ostatnia zmienna APP_NAME będzie przechowywała nazwę aplikacji Play.

Teraz musimy podrasować plik docker-compose aby używał tych zmiennych. Musimy zastąpić poświadczenia bazy danych przez ${?VARIABLE_NAME}. Twój cały plik docker-compose powinien wyglądać podobnie do tego z poniższego przykładu.

 services:
    db:
        image: postgres
        container_name: db
        restart: always
        ports:
            - "5432:5432"
        volumes:
            - ./docker/volumes/db:/var/lib/postgresql/data
        environment:
            - POSTGRES_USER=${POSTGRES_USER}
            - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
            - POSTGRES_DB=${POSTGRES_DB}
        play:
        image: rakbud-server:latest
        container_name: ${APP_NAME}
        restart: always
        ports:
            - "9000:9000"
        volumes:
        - ./conf:/opt/docker/conf
        - ./docker/volumes/play/files:/opt/docker/your-app-name_files
        - ./docker/volumes/play/logs:/opt/docker/logs
        environment:
            - POSTGRES_USER=${POSTGRES_USER}
            - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
            - POSTGRES_DB=${POSTGRES_DB}
        depends_on:
            - db 

 

Ostatnim krokiem jest otwarcie naszego terminala, wpisanie cd do katalogu z plikiem docker-compose i uruchomienie:

 docker-compose config 

To polecenie sprawdzi, czy utworzony docker-compose jest poprawny. Jeśli jest, to wypisze go do terminala, gdzie można sprawdzić, czy zmienne środowiskowe zostały ustawione poprawnie.

Teraz, gdy mamy poprawny plik docker-compose możemy uruchomić

 docker-compose up -d 

Ten komentarz uruchomi nasze kontenery w trybie detached, czyli będzie uruchamiał kontenery w tle. Aby uzyskać logi z kontenerów należy uruchomić:

 docker-compose logs