Laravel + Docker + Gitlab. Wo soll ich anfangen?

Normalerweise habe ich immer auf einen Docker verzichtet und dachte, dass ein Docker nur für große Projekte in großen Unternehmen benötigt wird. Aber eines Tages sah ich, wie ein Docker zusammen mit dem Gitlab eines Freundes arbeitet, und erkannte, dass ich es noch studieren sollte. Wie gewöhnlich habe ich jedoch keinen geeigneten Artikel gefunden - sie waren entweder zu komplex oder unvollständig oder implizierten, dass Sie alle von sich aus wissen. Ich musste lange nach verschiedenen Quellen suchen, alles zusammenstellen und am Ende schaffte ich es, ein einfaches Projekt und CI / CD dafür zu erstellen.

Alle Arbeiten können in drei Teile unterteilt werden: auf dem lokalen Computer, auf dem Hitlab und auf dem Server.

Für die Implementierung des Projekts benötigen wir daher ein Gitlab-Konto und einen Remote-Server mit KVM- oder XEN-Virtualisierung.

Teil 1. Lokale Maschine


Auf dem lokalen Computer müssen Sie Docker installieren.

Kommentar
. Docker Linux ( Ubuntu, ), Windows MacOS. macos , Windows . - , linux . - , . VirtualBox. Ubuntu

Um in einer Linux-Umgebung zu installieren, müssen Sie die folgenden Befehle ausführen.

Alte Container löschen:

sudo apt-get remove docker docker-engine docker.io containerd runc

Update apt:

sudo apt-get update

Installieren Sie die folgenden Pakete, damit Sie Docker über https aus dem Repository herunterladen können:

sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

Fügen Sie den offiziellen GPG-Docker-Schlüssel hinzu:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Stellen Sie sicher, dass der Druck korrekt ist:

sudo apt-key fingerprint 0EBFCD88

Antworten:

pub   rsa4096 2017-02-22 [SCEA]
      9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid           [ unknown] Docker Release (CE deb) <docker@docker.com>
sub   rsa4096 2017-02-22 [S]

Laden Sie die stabile Version herunter:

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

Update apt erneut:

sudo apt-get update

Installieren Sie die neueste Docker-Engine:

sudo apt-get install docker-ce docker-ce-cli containerd.io

Überprüfen Sie die Docker-Funktion:

sudo docker run hello-world

Wenn alles korrekt ist, beginnt der Download des Hello World-Bildes.

Vollständige Anweisungen in der offiziellen Dokumentation des Dockers .

Wir müssen auch Docker-Compose installieren. Die offizielle Anweisung ist hier .

Führen Sie zum Installieren die Befehle im Terminal aus.

Aus dem Repository herunterladen:

sudo curl -L "https://github.com/docker/compose/releases/download/1.25.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Hinzufügen eines Übungsrechts:

sudo chmod +x /usr/local/bin/docker-compose

Versionsprüfung:

sudo docker-compose --version

Wir haben den Docker installiert, jetzt ist es notwendig, das Image zu sammeln. Zu diesem Zweck habe ich den Artikel von der Digitalocean-Website verwendet: www.digitalocean.com/community/tutorials/how-to-set-up-laravel-nginx-and-mysql-with-docker-compose-ru . Es wird einen Nachdruck dieses Artikels geben.

Herunterladen von Laravel und Installieren von Abhängigkeiten

Im ersten Schritt laden wir die neueste Version von Laravel herunter und installieren die Projektabhängigkeiten, einschließlich Composer, dem PHP-Paketmanager auf Anwendungsebene. Wir werden diese Abhängigkeiten mit Docker installieren, um keine globale Installation von Composer durchzuführen.

Gehen Sie zu Ihrem Home-Verzeichnis und klonen Sie die neueste Version von Laravel in ein Verzeichnis namens laravel-app:

cd ~
git clone https://github.com/laravel/laravel.git laravel-app

Gehe zum Laravel-App-Verzeichnis:

cd ~/laravel-app

Hängen Sie dann das Composer-Image von Docker in die Verzeichnisse ein, die Sie für Ihr Laravel-Projekt benötigen, um den Aufwand für die globale Installation von Composer zu vermeiden:

docker run --rm -v $(pwd):/app composer install

Die Flags -v und --rm des Docker-Befehls run erstellen einen virtuellen Container, der bis zum Löschen an das aktuelle Verzeichnis gebunden wird. Der Inhalt Ihres Verzeichnisses ~ / laravel-app wird in den Container kopiert, und der Inhalt des Composer, der im Container des Herstellerordners erstellt wurde, wird in das aktuelle Verzeichnis kopiert.

Legen Sie abschließend die Berechtigungsstufe im Projektverzeichnis so fest, dass sie einem Benutzer ohne Root-Rechte gehört:

sudo chown -R $USER:$USER ~/laravel-app

Dies ist wichtig, wenn Sie die Docker-Datei für das Image Ihrer Anwendung schreiben, da Sie damit mit dem Anwendungscode arbeiten und Prozesse im Container ohne Root-Rechte starten können.

Jetzt haben Sie den Anwendungscode platziert und können mit Docker Compose mit der Definition von Diensten fortfahren.

Erstellen einer Docker Compose-Datei Erstellen von

Anwendungen mit Docker Compose vereinfacht den Konfigurations- und Versionsprozess in Ihrer Infrastruktur. Um unsere Laravel-Anwendung anzupassen, erstellen wir eine Docker-Compose-Datei mit der Definition von Webserverdiensten, Datenbank und Anwendung.

Öffne die Datei:

nano ~/laravel-app/docker-compose.yml

In der Docker-Compose-Datei sind drei Dienste definiert: App, Webserver und Datenbank. Fügen Sie der Datei den folgenden Code hinzu, während Sie das Root-Passwort für MYSQL_ROOT_PASSWORD, das als Umgebungsvariable des DB-Dienstes definiert ist, durch ein Passwort Ihrer Wahl ersetzen:

~/laravel-app/docker-compose.yml

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge

Folgende Leistungen sind hier enthalten:

  • App: Diese Service-Definition enthält die Laravel-Anwendung und startet das personalisierte Docker-Image digitalocean.com/php. Außerdem wird der Parameter working_dir im Container auf / var / www gesetzt.
  • Webserver: Diese Dienstdefinition übernimmt das nginx: alpine-Image von Docker und öffnet die Ports 80 und 443.
  • db: Diese Dienstdefinition ruft das mysql: 5.7.22-Image von Docker ab und definiert neue Umgebungsvariablen, einschließlich der Laravel-Datenbank für Ihre Anwendung und des Root-Kennworts für die Datenbank. Sie können einen beliebigen Datenbanknamen verwenden. Sie sollten auch Ihr_mysql_root_password durch Ihr eigenes sicheres Passwort ersetzen. Diese Dienstdefinition ordnet auch den Host-Port 3306 dem Container-Port 3306 zu.

Jede Eigenschaft container_name definiert einen Containernamen, der dem Dienstnamen entspricht. Wenn Sie diese Eigenschaft nicht definieren, gibt Docker jedem Container Namen, die aus dem Namen einer historischen Person und einem zufälligen Wort bestehen und durch einen Unterstrich getrennt sind.

Um die Interaktion zwischen Containern zu vereinfachen, stellen Dienste eine Verbindung zum Verbindungsnetzwerk her, das als App-Netzwerk bezeichnet wird. Das Verbindungsnetzwerk verwendet eine Softwarebrücke, über die mit diesem Netzwerk verbundene Container miteinander kommunizieren können. Der Brückentreiber legt automatisch Hostregeln fest, sodass Container in verschiedenen Verbindungsnetzwerken nicht direkt miteinander kommunizieren können. Dies verbessert die Anwendungssicherheit, da nur verwandte Dienste miteinander kommunizieren können. Dies bedeutet auch, dass Sie verschiedene Netzwerke und Dienste angeben können, die eine Verbindung zu verwandten Funktionen herstellen: Beispielsweise können Clientanwendungsdienste das Frontend-Netzwerk und Serverdienste das Backend-Netzwerk verwenden.

Lassen Sie uns nun sehen, wie Sie Volumes hinzufügen und gemountete Images an Dienstdefinitionen binden, um Anwendungsdaten dauerhaft zu speichern.

Persistente Datenspeicherung

Docker verfügt über leistungsstarke und bequeme Mittel zur persistenten Datenspeicherung. In unserer Anwendung verwenden wir Volumes und gemountete Images, um Datenbankdateien, Anwendungen und Konfigurationen dauerhaft zu speichern. Volumes bieten Flexibilität und Beibehaltung der Sicherung nach Beendigung des Lebenszyklus des Containers. Bereitstellbare bereitstellbare Images vereinfachen Codeänderungen während der Entwicklung, indem sie Änderungen an Hostdateien oder Verzeichnissen in Containern sofort widerspiegeln. Wir verwenden beide Optionen.

Warnung!
, , . , Docker . .

Definieren Sie das Volume mit dem Namen dbdata in der Docker-Compose-Datei in der Datenbankdienstdefinition, um die MySQL-Datenbank beizubehalten:

~/laravel-app/docker-compose.yml

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
    networks:
      - app-network
  ...

Ein Volume mit dem Namen dbdata wird verwendet, um den Inhalt des Ordners / var / lib / mysql dauerhaft im Container zu speichern. Auf diese Weise können Sie den Datenbankdienst stoppen und neu starten, ohne Daten zu verlieren.
Fügen Sie am Ende der Datei eine Definition des DBData-Volumes hinzu:

~/laravel-app/docker-compose.yml

...
#Volumes
volumes:
  dbdata:
    driver: local

Mit dieser Definition können Sie dieses Volume für verschiedene Dienste verwenden.

Fügen Sie dann die Mount-Image-Bindung zum Datenbankdienst für die MySQL-Konfigurationsdateien hinzu:

~/laravel-app/docker-compose.yml

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
  ...

Dieses gemountete Image bindet die Datei ~ / laravel-app / mysql / my.cnf an das Verzeichnis /etc/mysql/my.cnf im Container.

Fügen Sie dann die bereitgestellten Images zum Webserverdienst hinzu. Es gibt zwei: eine für den Anwendungscode und die andere für die Bestimmung der Nginx-Konfiguration

~/laravel-app/docker-compose.yml

#Nginx Service
webserver:
  ...
  volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
  networks:
      - app-network

Das erste gemountete Image bindet den Anwendungscode im Verzeichnis ~ / laravel-app an das Verzeichnis / var / www im Container. Die Konfigurationsdatei, die zu ~ / laravel-app / nginx / conf.d / hinzugefügt wurde, wird auch in /etc/nginx/conf.d/ im Container bereitgestellt, sodass Sie den Inhalt des Konfigurationsverzeichnisses nach Bedarf hinzufügen und ändern können.

Fügen Sie abschließend dem App-Service die folgenden Bereitstellungen von gemounteten Images für Anwendungscode und Konfigurationsdateien hinzu:

~/laravel-app/docker-compose.yml

#PHP Service
app:
  ...
  volumes:
       - ./:/var/www
       - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
  networks:
      - app-network

Der App-Dienst bindet das gemountete Image des Ordners ~ / laravel-app, der den Anwendungscode enthält, an den Ordner / var / www. Dies beschleunigt den Entwicklungsprozess, da alle Änderungen im lokalen Anwendungsverzeichnis sofort im Container angezeigt werden. Sie verknüpfen auch die PHP-Konfigurationsdatei ~ / laravel-app / php / local.ini mit der Datei /usr/local/etc/php/conf.d/local.ini im Container. Später erstellen Sie eine lokale PHP-Konfigurationsdatei.

Ihre Docker-Compose-Datei sieht nun folgendermaßen aus:

~/laravel-app/docker-compose.yml

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    volumes:
      - ./:/var/www
      - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - dbdata:/var/lib/mysql/
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge
#Volumes
volumes:
  dbdata:
    driver: local

Erstellen einer

Docker- Datei Mit Docker können Sie die Umgebung in einzelnen Containern mithilfe einer Docker-Datei definieren. Mit Dockerfile können Sie personalisierte Bilder erstellen. Hiermit können Sie die erforderliche Anwendungssoftware installieren und die Einstellungen nach Bedarf ändern. Sie können erstellte Bilder an den Docker Hub oder eine beliebige private Registrierung übertragen.

Die Docker-Datei befindet sich im Verzeichnis ~ / laravel-app. Erstellen Sie eine Datei:

nano ~/laravel-app/Dockerfile

Diese Docker-Datei gibt das Basis-Image sowie die erforderlichen Befehle und Anweisungen zum Erstellen des Laravel-Anwendungs-Images an. Fügen Sie der Datei den folgenden Code hinzu:

~/laravel-app/php/Dockerfile

FROM php:7.2-fpm

# Copy composer.lock and composer.json
COPY composer.lock composer.json /var/www/

# Set working directory
WORKDIR /var/www

# Install dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    mysql-client \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    vim \
    unzip \
    git \
    curl

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Install extensions
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --with-gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/ --with-png-dir=/usr/include/
RUN docker-php-ext-install gd

# Install composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Add user for laravel application
RUN groupadd -g 1000 www
RUN useradd -u 1000 -ms /bin/bash -g www www

# Copy existing application directory contents
COPY . /var/www

# Copy existing application directory permissions
COPY --chown=www:www . /var/www

# Change current user to www
USER www

# Expose port 9000 and start php-fpm server
EXPOSE 9000
CMD ["php-fpm"]

Zuerst erstellt die Docker-Datei das Bild über dem PHP: 7.2-fpm Docker-Bild. Dies ist ein Image, das auf einer installierten Instanz von PHP FastCGI PHP-FPM basiert. Diese Datei installiert auch die erforderlichen Pakete für Laravel: mcrypt, pdo_mysql, mbstring und imagick with composer.

Die RUN-Direktive gibt Befehle zum Aktualisieren, Installieren und Konfigurieren von Parametern in einem Container an, einschließlich eines dedizierten Benutzers und einer Gruppe mit dem Namen www. Die Anweisung WORKDIR legt das Verzeichnis / var / www als Arbeitsverzeichnis der Anwendung fest.

Durch das Erstellen eines separaten Benutzers und einer Gruppe mit eingeschränkten Zugriffsrechten wird die Sicherheitsanfälligkeit beim Starten von Docker-Containern verringert, die standardmäßig mit Root-Rechten ausgeführt werden. Anstatt diesen Container mit Root-Rechten auszuführen, haben wir mit dem Befehl COPY und dem Flag --chown einen WWW-Benutzer mit Lese- und Schreibberechtigungen für den Ordner / var / www erstellt, um die Berechtigungen des Anwendungsordners zu kopieren.

Der Befehl EXPOSE öffnet Port 9000 im Container für den php-fpm-Server. CMD gibt den Befehl an, der ausgeführt werden soll, nachdem der Container erstellt wurde. Hier gibt CMD den Befehl php-fpm an, mit dem der Server gestartet wird.

Wenn Sie mit den Änderungen fertig sind, speichern Sie die Datei und schließen Sie den Editor.

Jetzt können Sie mit der Definition Ihrer PHP-Konfiguration fortfahren.

PHP-Setup

Sie haben die Infrastruktur in der Docker-Compose-Datei definiert und können jetzt den PHP-Dienst so konfigurieren, dass er als PHP-Prozessor für eingehende Nginx-Anforderungen fungiert.

Um PHP zu konfigurieren, erstellen Sie eine local.ini-Datei im PHP-Ordner. Dies ist die Datei, die Sie mit der Datei /usr/local/etc/php/conf.d/local.ini im obigen Container verknüpft haben. Wenn Sie diese Datei erstellen, können Sie die Standarddatei php.ini ignorieren, die PHP beim Start liest.

Erstellen Sie ein PHP-Verzeichnis:

mkdir ~/laravel-app/php

Öffnen Sie dann die Datei local.ini:

nano ~/laravel-app/php/local.ini

Um das PHP-Setup zu demonstrieren, fügen wir den folgenden Code hinzu, um die Größenbeschränkungen für das Hochladen von Dateien festzulegen:

~/laravel-app/php/local.ini

upload_max_filesize=40M
post_max_size=40M

Die Anweisungen upload_max_filesize und post_max_size legen die maximal zulässige Größe der hochgeladenen Dateien fest und zeigen, wie die Konfigurationen von php.ini aus der Datei local.ini festgelegt werden. Sie können jeden PHP-Konfigurationsparameter, den Sie ignorieren möchten, in die Datei local.ini einfügen.

Konfigurieren von Nginx

Wenn Sie den PHP-Dienst konfigurieren, können Sie den Nginx-Dienst so ändern, dass PHP-FPM als FastCGI-Server für die Bereitstellung dynamischer Inhalte verwendet wird. Der FastCGI-Server basiert auf einem Binärprotokoll für die Interaktion interaktiver Programme mit einem Webserver. Weitere Informationen finden Sie im Artikel „Grundlegendes zu und Implementieren von FastCGI-Proxies in Nginx“.
Um Nginx zu konfigurieren, erstellen Sie eine app.conf-Datei mit der Dienstkonfiguration im Ordner ~ / laravel-app / nginx / conf.d /.

Erstellen Sie zuerst das Verzeichnis nginx / conf.d /:

mkdir -p ~/laravel-app/nginx/conf.d

Erstellen Sie dann die Konfigurationsdatei app.conf:

nano ~/laravel-app/nginx/conf.d/app.conf

Fügen Sie der Datei den folgenden Code hinzu, um Nginx zu konfigurieren:

~/laravel-app/nginx/conf.d/app.conf

server {
    listen 80;
    index index.php index.html;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
    location / {
        try_files $uri $uri/ /index.php?$query_string;
        gzip_static on;
    }
}

Der Serverblock konfiguriert den Nginx-Webserver mithilfe der folgenden Anweisungen:

  • listen: Diese Anweisung definiert den Port, den der Server auf eingehende Anforderungen überwacht.
  • error_log und access_log: Diese Anweisungen definieren Dateien für die Protokollierung.
  • root: Diese Anweisung legt den Pfad zum Stammordner fest und bildet den vollständigen Pfad für jede angeforderte Datei im lokalen Dateisystem.

Im PHP-Speicherortblock zeigt die Anweisung fastcgi_pass an, dass der App-Dienst einen TCP-Socket an Port 9000 überwacht. Damit überwacht der PHP-FPM-Server das Netzwerk und nicht den Unix-Socket. Obwohl der Unix-Socket einen leichten Geschwindigkeitsvorteil gegenüber dem TCP-Socket bietet, verfügt er nicht über ein Netzwerkprotokoll und überspringt den Netzwerkstapel. In Fällen, in denen sich Hosts auf demselben System befinden, kann die Verwendung eines Unix-Sockets sinnvoll sein. Wenn die Dienste jedoch auf verschiedenen Hosts ausgeführt werden, bietet der TCP-Socket einen Vorteil, da Sie eine Verbindung zu verteilten Diensten herstellen können. Da unsere App- und Webserver-Container auf verschiedenen Hosts ausgeführt werden, ist es effizienter, in unserer Konfiguration einen TCP-Socket zu verwenden.

Wenn Sie mit den Änderungen fertig sind, speichern Sie die Datei und schließen Sie den Editor.

Dank der zuvor erstellten Bindung werden alle Änderungen im Ordner nginx / conf.d / direkt im Webserver-Container angezeigt.

Schauen wir uns nun die MySQL-Parameter an.

Einrichten von MySQL

Nach dem Einrichten von PHP und Nginx können Sie MySQL als Datenbank für Ihre Anwendung aktivieren.

Um MySQL zu konfigurieren, müssen Sie die Datei my.cnf im Ordner mysql erstellen. Dies ist die Datei, die Sie während des Datenbankkonfigurationsschritts an die Datei /etc/mysql/my.cnf im Container angehängt haben. Durch das Mounten des gemounteten Images können Sie bei Bedarf alle my.cnf-Optionen ignorieren.

Um zu demonstrieren, wie dies funktioniert, fügen wir my.cnf Einstellungen hinzu, die das allgemeine Anforderungsprotokoll enthalten, und legen die Protokolldatei fest.

Erstellen Sie ein MySQL-Verzeichnis:

mkdir ~/laravel-app/mysql

Erstellen Sie die Datei my.cnf:

nano ~/laravel-app/mysql/my.cnf

Fügen Sie der Datei den folgenden Code hinzu, um das Abfrageprotokoll zu aktivieren und den Speicherort der Protokolldatei festzulegen:

~/laravel-app/mysql/my.cnf

[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log

Die Datei my.cnf unterstützt Protokolle, indem der Parameter general_log auf 1 gesetzt wird, wodurch allgemeine Protokolle aktiviert werden. Der Parameter general_log_file gibt an, wo die Protokolle gespeichert werden.

Container starten und Umgebungseinstellungen ändern

Sie haben alle Dienste in der Docker-Compose-Datei definiert und Konfigurationsdateien für diese Dienste erstellt. Jetzt können Sie Container ausführen. Abschließend erstellen wir eine Kopie der .env.example-Datei, die Laravel standardmäßig enthält, und nennen sie .env, da Laravel eine solche Datei verwendet, um die Umgebung zu bestimmen:

cp .env.example .env

Nach dem Starten der Container konfigurieren wir bestimmte Installationsparameter in dieser Datei.

Jetzt sind alle Ihre Dienste in der Docker-Compose-Datei definiert, und Sie müssen nur noch einen Befehl ausführen, um alle Container zu starten, Volumes zu erstellen und Netzwerke zu konfigurieren und zu verbinden:

docker-compose up -d

Wenn Sie Docker-Compose zum ersten Mal starten, werden alle erforderlichen Docker-Images heruntergeladen. Dies kann einige Zeit dauern. Nachdem Sie die Bilder heruntergeladen und auf dem lokalen Computer gespeichert haben, erstellt Compose Ihre Container. Das Flag -d konvertiert den Prozess in einen Daemon, mit dem Container im Hintergrund ausgeführt werden.

Verwenden Sie nach Abschluss des Vorgangs den folgenden Befehl, um alle laufenden Container aufzulisten:
docker ps


Sie sehen die folgenden Ergebnisse mit Daten auf den App-, Webserver- und Datenbankcontainern:

Output
CONTAINER ID        NAMES               IMAGE                             STATUS              PORTS
c31b7b3251e0        db                  mysql:5.7.22                      Up 2 seconds        0.0.0.0:3306->3306/tcp
ed5a69704580        app                 digitalocean.com/php              Up 2 seconds        9000/tcp
5ce4ee31d7c0        webserver           nginx:alpine                      Up 2 seconds        0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp

In diesen Ergebnissen ist die CONTAINER-ID eine eindeutige Kennung für jeden Container, und NAMES listet die Dienstnamen für jeden Container auf. Sie können beide Bezeichner verwenden, um auf Container zuzugreifen. IMAGE definiert den Bildnamen jedes Containers und STATUS bietet Informationen zum Status des Containers: gestartet, neu gestartet oder gestoppt.

Jetzt können Sie die ENV-Datei im App-Container ändern, um Ihrem System bestimmte Parameter hinzuzufügen.

Öffnen Sie die Datei mit Docker-Compose Exec, mit der Sie bestimmte Befehle in Containern ausführen können. In diesem Fall öffnen Sie die Datei zur Bearbeitung:

docker-compose exec app nano .env

Suchen Sie den Block, in dem DB_CONNECTION angegeben ist, und aktualisieren Sie ihn entsprechend Ihrer Systemkonfiguration. Sie werden die folgenden Felder ändern:

  1. DB_HOST ist Ihr Datenbankdatenbankcontainer.
  2. DB_DATABASE ist die Laravel-Datenbank.
  3. DB_USERNAME ist der Benutzername für Ihre Datenbank. In diesem Fall verwenden wir Laraveluser.
  4. DB_PASSWORD ist ein Passwort, das für dieses Benutzerkonto geschützt ist.

/var/www/.env

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password

Es ist auch erforderlich, dieselben Variablen in der .env.example-Datei zu korrigieren, da sie später bei der Bereitstellung auf dem Server verwendet werden.

Konfigurieren Sie dann den Anwendungsschlüssel für Laravel mit dem Befehl php artisan key: generate. Dieser Befehl generiert einen Schlüssel und kopiert ihn in die ENV-Datei, wodurch Benutzersitzungen und verschlüsselte Daten geschützt werden:

docker-compose exec app php artisan key:generate

Jetzt haben Sie alle erforderlichen Umgebungseinstellungen, um die Anwendung auszuführen. Führen Sie den folgenden Befehl aus, um diese Einstellungen in einer Datei zwischenzuspeichern, die das Laden von Anwendungen beschleunigt.

docker-compose exec app php artisan config:cache

Die Konfigurationseinstellungen werden in die Datei /var/www/bootstrap/cache/config.php im Container geladen.

Öffnen Sie abschließend die localhost- Site in Ihrem Browser . Die Hauptseite der Laravel-Anwendung wird geöffnet.

Erstellen eines MySQL-Benutzers

Bei der Installation von MySQL wird standardmäßig nur ein administratives Stammkonto mit unbegrenzten Berechtigungen für den Zugriff auf den Datenbankserver erstellt. Wenn Sie mit einer Datenbank arbeiten, ist es normalerweise am besten, die Verwendung eines administrativen Stammkontos zu vermeiden. Stattdessen erstellen wir einen speziellen Datenbankbenutzer für die Laravel-Datenbank unserer Anwendung.
Um einen neuen Benutzer zu erstellen, starten Sie die interaktive Bash-Shell im Datenbankcontainer mit dem Befehl docker-compose exec:

docker-compose exec db bash

Melden Sie sich im Container beim MySQL-Root-Administratorkonto an:

mysql -u root -p

Bei der Installation in der Docker-Compose-Datei werden Sie aufgefordert, das für das MySQL-Root-Konto angegebene Kennwort einzugeben.

Überprüfen Sie zunächst die in der Docker-Compose-Datei definierte Laravel-Datenbank.
Führen Sie den Befehl show database aus, um vorhandene Datenbanken zu überprüfen:

show databases;

In den Ergebnissen sollte die Laravel-Datenbank angezeigt werden:

Output
+--------------------+
| Database           |
+--------------------+
| information_schema |
| laravel            |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

Erstellen Sie dann ein Benutzerkonto, das Zugriff auf diese Datenbank gewährt.
Wir verwenden den Laraveluser-Benutzernamen, aber Sie können ihn durch einen beliebigen bevorzugten Namen ersetzen. Stellen Sie einfach sicher, dass der Benutzername und das Kennwort mit denen in der ENV-Datei im vorherigen Schritt übereinstimmen:

GRANT ALL ON laravel.* TO 'laraveluser'@'%' IDENTIFIED BY 'your_laravel_db_password';

Aktualisieren Sie die Berechtigungen, um den MySQL-Server über Änderungen zu informieren:

FLUSH PRIVILEGES;

Schließen Sie MySQL:

EXIT;

Verlasse den Container:

exit

Jetzt können Sie die Migration durchführen, um die Datenbank zu testen:

docker-compose exec app php artisan migrate

Die Ergebnisse der Migrationsbestätigung lauten wie folgt:

Output

Migration table created successfully.
Migrating: 2014_10_12_000000_create_users_table
Migrated:  2014_10_12_000000_create_users_table
Migrating: 2014_10_12_100000_create_password_resets_table
Migrated:  2014_10_12_100000_create_password_resets_table

Teil 2. Gitlab


In Hitlab müssen Sie ein neues Projekt erstellen.

Jetzt müssen wir das Projekt im Hitlab-Repository speichern. Rufen Sie dazu die folgenden Befehle aus dem Projektordner auf dem lokalen Computer auf:

git init
git remote add origin git@gitlab.com:<>/<>  
git remote add origin https://gitlab.com/<>/<>      SSH
git add .
git commit -m "Initial commit"
git push -u origin master

Das Projekt sollte unter Projektübersicht -> Details angezeigt werden.
Damit die fertige Umgebung sofort abgerufen werden kann, speichern wir das Docker-Image der Umgebung im Hitlistenregister.

Dazu müssen Sie Folgendes tun:

docker login registry.gitlab.com

Und wirf das Bild auf gitlab:

docker build -t registry.gitlab.com/<>/<> .
docker push registry.gitlab.com/<>/<>

Das Bild befindet sich in Packages-> Container Registry.

Zum Abschluss von gitlab erhalten wir sofort den Schlüssel zu gitlab-running. Gehen Sie dazu zu Einstellung-> CI / CD-> Runner. Der Schlüssel befindet sich in Schritt 3 im Abschnitt Manuelle Konfiguration (Manuelles Einrichten eines bestimmten Läufers).

Teil 3. Serverkonfiguration


Der VPS-Server muss mit dem Virtualisierungstyp KVM oder XEN belegt sein. Virtualisierung wie OpenVZ teilt den Kern des Systems zwischen allen Benutzern, sodass die Kernelparameter nicht geändert werden können. Für den Test habe ich den KVM-Server mit vorinstalliertem Docker verwendet. Möglicherweise befindet sich jedoch kein Docker auf dem Server. In diesem Fall müssen Sie es manuell installieren. Der Algorithmus ist der gleiche wie bei der Installation auf dem lokalen Computer. Es ist auch notwendig, die PHP-Version zu überprüfen. Für Laravel benötigen Sie mindestens 7.2. Ich musste auch die Erweiterung für PHP ext-mbstring separat installieren (in meinem Fall für PHP 7.3):

sudo apt-get update
sudo apt-get install php7.3-mbstring

Als nächstes müssen wir Gitlab-Runner installieren. Runner ist ein Dienst, der beim Empfang einer neuen Version einen Webhook von einem Hitlab akzeptiert und alles auf unserem Server bereitstellt.

Um gitlab-running zu installieren, müssen Sie Folgendes tun:

curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

Legen Sie nach dem Herunterladen die Berechtigung zum Ausführen fest:

sudo chmod +x /usr/local/bin/gitlab-runner

Erstellen Sie als Nächstes den Gitlab-Runner-Benutzer und führen Sie den Gitlab-Runner-Dienst aus:

sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash
sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
sudo gitlab-runner start

Läufer registrieren. Dazu benötigen wir das Token aus Teil 2 dieses Artikels:

sudo gitlab-runner register

Als Antwort werden Sie nach der Adresse Ihres Hitlab gefragt.

Geben Sie gitlab.com :

Please enter the gitlab-ci coordinator URL (e.g. https://gitlab.com )
https://gitlab.com

Als nächstes müssen Sie den Token eingeben. Geben Sie den Token aus Teil 2 ein.

Please enter the gitlab-ci token for this runner
xxx

Geben Sie als Nächstes eine durch Kommas getrennte Beschreibung und Tags an. Dann wird uns angeboten, einen Testamentsvollstrecker auszuwählen. Hier müssen Sie eine Shell auswählen:


Please enter the executor:
shell

Nach meinem Verständnis ist der Executor eine Umgebung, in der der Code aus der Datei .gitlab-ci.yml ausgeführt wird. Es stehen Bash, SSH, Docker, Parallelen, Virtualbox und Kubernets zur Auswahl. In der Dokumentation wird empfohlen, bash zu verwenden, wenn Sie nicht wissen, was Sie verwenden sollen. Dies ist eine universelle Option, die in der Befehlszeile Ihres Servers ausgeführt wird.

Dann müssen wir den Gitlab-Runner-Benutzer zur Docker-Benutzergruppe hinzufügen.

sudo usermod -aG docker gitlab-runner

Fügen Sie sudoers hinzu, um Zugriffsfehler zu vermeiden

sudo nano /etc/sudoers

Linie

gitlab-runner ALL=(ALL) NOPASSWD: ALL

Jetzt können wir die Datei .gitlab-ci.yml erstellen. Für die Ausführung der sogenannten Pipeline ist Folgendes erforderlich: eine Folge von Befehlen zum Bereitstellen eines Projekts.

Gehen Sie dazu zum Projekt-Repository in der Trefferliste und klicken Sie auf Neue Datei erstellen. Gitlab selbst bietet Dateivorlagen an, unter denen Sie .gitlab-ci.yml auswählen müssen. Nach dem Erstellen einer Datei in gitlab können Sie eine Vorlage für den Inhalt der Datei auswählen. Ich habe mich für Laravel entschieden und es ein wenig für mich überarbeitet:


# This file is a template, and might need editing before it works on your project.
# Official framework image. Look for the different tagged releases at:
# https://hub.docker.com/r/library/php
# .    ,        
image: registry.gitlab.com/<>/<>:latest

# Pick zero or more services to be used on all builds.
# Only needed when using a docker container to run your tests in.
# Check out: http://docs.gitlab.com/ce/ci/docker/using_docker_images.html#what-is-a-service
services:
  - mysql:latest
#    
variables:
  MYSQL_DATABASE: laravel
  MYSQL_ROOT_PASSWORD: ***********

# This folder is cached between builds
# ,      
# http://docs.gitlab.com/ce/ci/yaml/README.html#cache
cache:
  paths:
    - vendor/
    - node_modules/

# This is a basic example for a gem or script which doesn't use
# services such as redis or postgres
#     
before_script:
  #   
  - sudo apt-get update -yqq
  #    nodejs
  - sudo apt-get install gnupg -yqq
  #  Node   12
  - curl -sL https://deb.nodesource.com/setup_12.x | sudo bash -
  #  
  - sudo apt-get install git nodejs libcurl4-gnutls-dev libicu-dev libmcrypt-dev libvpx-dev libjpeg-dev libpng-dev libxpm-dev zlib1g-dev libfreetype6-dev libxml2-dev libexpat1-dev libbz2-dev libgmp3-dev libldap2-dev unixodbc-dev libpq-dev libsqlite3-dev libaspell-dev libsnmp-dev libpcre3-dev libtidy-dev -yqq
  #  composer
  - curl -sS https://getcomposer.org/installer | php
  - php composer.phar install
  - composer install
  #   Node
  - npm install
  # Copy over testing configuration.
  # Don't forget to set the database config in .env.testing correctly
  - DB_HOST=mysql
  - DB_DATABASE=laravel
  - DB_USERNAME=root
  - DB_PASSWORD=*********
  #  .env.example    .env
  - cp .env.example .env
  #  npm build
  - npm run dev
  #       laravel
  - php artisan key:generate
  - php artisan config:cache
  - php artisan route:clear
  - php artisan config:clear
  - php artisan cache:clear
  #  .
  - docker-compose exec app php artisan migrate
  #   
  #- docker-compose exec app php artisan db:seed

#
test:
  script:
    #  
    - php vendor/bin/phpunit --coverage-text --colors=never
    #  npm
    - npm test

#       
deploying:
  stage: deploy
  script:
    - echo "Deployed"
    - docker-compose stop
    - docker-compose up -d

Nachdem Sie die Pipeline (CI / CD-> Pipelines) erfolgreich an der IP-Adresse Ihres Servers ausgeführt haben, sollte Ihre Laravel-Seite angezeigt werden.

Um CI / CD zu konfigurieren, habe ich Anweisungen von Sean Bradley verwendet:


und medium.com/@sean_bradley/auto-devops-with-gitlab-ci-and-docker-compose-f931233f080f

All Articles