Bereitstellen eines Play-Servers mit Docker Compose und Postgres

Eine der einfachsten Möglichkeiten, so gut wie jede Anwendung bereitzustellen, ist die Verwendung von Docker-Containern. Es gibt eine Fülle von Hosting-Seiten, die Container-Hosting anbieten, oder Sie können Ihren Dienst selbst hosten, indem Sie einen dedizierten Server oder VPS verwenden. Die manuelle Verwaltung verschiedener Docker-Container mit Umgebungsvariablen, gemappten Ports und Volumes kann ziemlich mühsam sein. Hier kommt Docker Compose ins Spiel.

Docker Compose

In der Docker-Dokumentation heißt es:

Compose ist ein Tool zur Definition und Ausführung von Docker-Anwendungen mit mehreren Containern.

Dies bedeutet, dass wir in der Lage sein werden, mehrere containerisierte Anwendungen zu erstellen, auszuführen und zu verwalten. Für diesen Artikel werden wir zwei Dienste erstellen: einen PlayFramework-Backend-Server und eine PostgreSQL-Datenbank. Wenn Sie eine Frontend-Anwendung oder eine Art von Administrationspanel hosten müssen, können Sie weitere Dienste zu Ihrer Docker-Compose Datei hinzufügen.

Database service – PostgreSQL

Als erstes müssen wir eine Datei docker-compose.yml erstellen. Danach können wir mit der Konfiguration beginnen. Das erste, was wir hinzufügen müssen, ist ein Element der obersten Ebene: services in der ersten Zeile unserer Datei. Der erste Dienst, den wir erstellen werden, ist unsere Datenbank. Dafür werden wir das PostgreSQL-Image verwenden. Der Dienst wird db heißen. Vergewissern Sie sich, dass Ihr Dienst einen Einzug tiefer als das services-Element steht und alle anderen Elemente die gleiche Anzahl von Einzügen haben, wie im Beispiel unten.

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 

Erläutern wir diese Konfiguration:

• db: – Name der Dienstleistung
• image: postgres – gibt das Image an, das wir verwenden wollen. In diesem Fall ist es Postgres.
• container_name: db – Name des Containers, der erstellt werden soll
• restart: always – legt die Neustartrichtlinie für Container fest
• ports – ordnet Container-Ports den Ports des Host-Rechners zu
• volumes – erstellt ein Docker-Volume, um Datenbankdaten auf dem Host-Rechner zu speichern
• environment – setzt die Umgebungsvariablen des Containers. Das PostgreSQL-Image ermöglicht es uns, Benutzer und Datenbank bei der Initialisierung des Containers zu erstellen, indem Umgebungsvariablen gesetzt werden.

PlayFramework server application service

Der nächste Dienst, den wir benötigen, ist unser Play-Backend-Server. Hierfür verwenden wir ein Play-Anwendungsimage. Wenn Sie nicht wissen, wie man ein solches erstellt, können Sie sich diesen Artikel ansehen. We will call this service 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 

Dieser Dienst enthält ein neues Element: depends_on. Damit wird sichergestellt, dass unsere Spielanwendung nach db, der unser Datenbankcontainer ist. Wenn Sie nicht wissen, warum in diesem Dienst etwas so eingestellt ist, wie es ist, finden Sie die Antwort wahrscheinlich in diesem Artikel, in dem wir Ihnen zeigen, wie Sie ein Play-Server-Image erstellen.

Da wir Umgebungsvariablen verwenden, um Datenbankanmeldeinformationen und Namen an unseren Play-Server-Container zu übergeben, müssen wir die Konfigurationsdatei von Play ändern, um diese Variablen zu verwenden.

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

Bei der obigen Datenbankkonfiguration werden bestimmte Variablen an bestimmten Stellen platziert. Da wir eine PostgreSQL-Datenbank verwenden, müssen wir zunächst den richtigen Treiber einstellen. Als Nächstes wollen wir uns in der URL mit der Datenbank verbinden, die vom db service auf Port 5432 gehostet wird. Wir können einfach den Namen unseres Dienstes mit einem bestimmten Port als Teil unserer URL verwenden. Dann fügen wir mit ${?POSTGRES_DB} den Datenbanknamen aus der Umgebungsvariablen an die URL „jdbc:postgresql://db:5432/“ an. Wir setzen den Benutzernamen und das Passwort der Datenbank auf die gleiche Weise – mit ${?VARIABLE_NAME}.

Environment Variables

Wie Sie vielleicht bemerken, mussten wir die Datenbankanmeldedaten in beiden Diensten duplizieren. Wir können dies vereinfachen, indem wir Umgebungsvariablen in unserer Datei docker-compose.yml verwenden. Zu diesem Zweck erstellen wir eine .env-Datei im selben Verzeichnis wie die vorherige Datei. Sie sollte wie folgt aussehen:

POSTGRES_USER=user

POSTGRES_PASSWORD=password

POSTGRES_DB=database-name

APP_NAME=play-app-server

 

Die letzte Variable APP_NAME speichert den Namen der Play-Anwendung.

Nun müssen wir die Datei docker-compose so anpassen, dass sie diese Variablen verwendet. Wir müssen die Datenbank-Anmeldeinformationen durch ${?VARIABLE_NAME} ersetzen. Ihre gesamte docker-compose-Datei sollte ähnlich aussehen wie die im folgenden Beispiel.

 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 

 

Im letzten Schritt öffnen wir unser Terminal, geben cd in das Verzeichnis mit der Datei docker-compose ein und führen es aus:

 docker-compose config 

Dieser Befehl prüft, ob das erstellte docker-compose korrekt ist. Ist dies der Fall, wird er im Terminal ausgegeben, wo Sie überprüfen können, ob die Umgebungsvariablen korrekt gesetzt wurden.

Da wir nun eine korrekte docker-compose Datei haben, können wir Folgendes ausführen

 docker-compose up -d 

Dieser Kommentar startet unsere Container im Detached Mode, d.h. er lässt die Container im Hintergrund laufen. Um Protokolle von Containern zu erhalten, müssen Sie Folgendes ausführen:

 docker-compose logs