🤸🏾 🧑🏻 ❤️ Laravel + Docker + Gitlab. Où commencer ⚾️ 🤜🏾 🍴

J'ai toujours fait sans docker et je pensais qu'un docker n'était nécessaire que pour les grands projets dans les grandes entreprises. Mais un jour, j'ai vu comment un docker fonctionne en tandem avec le gitlab d'un ami et j'ai réalisé que je devais encore l'étudier. Cependant, comme d'habitude, je n'ai pas trouvé d'article approprié - ils étaient soit trop complexes ou incomplets, soit implicites que vous le savez tous par vous-même. J'ai dû chercher diverses sources pendant longtemps, tout mettre ensemble et j'ai finalement réussi à faire un projet simple et un CI / CD.

Tout le travail peut être divisé en trois parties: sur la machine locale, sur la hitlab et sur le serveur.

Donc, pour la mise en œuvre du projet, nous avons besoin d'un compte gitlab et d'un serveur distant avec virtualisation KVM ou XEN.

Partie 1. Machine locale

Sur la machine locale, vous devez installer Docker.

Commentaire

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

Pour installer sur un environnement Linux, vous devez exécuter les commandes suivantes.

Supprimer les anciens conteneurs:

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

Mettre à jour apt:

sudo apt-get update

Installez les packages suivants afin de pouvoir télécharger Docker depuis le référentiel via https:

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

Ajouter la clé Docker GPG officielle:

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

Assurez-vous que l'impression est correcte:

sudo apt-key fingerprint 0EBFCD88

Réponse:

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]

Téléchargez la version stable:

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

Mettre à jour apt à nouveau:

sudo apt-get update

Installez le dernier moteur docker:

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

Vérifier le fonctionnement du docker:

sudo docker run hello-world

Si tout est correct, le téléchargement de l'image Hello World commencera.

Instructions complètes dans la documentation officielle du docker .

Nous devons également installer docker-compose. L'instruction officielle est ici .

Pour l'installer, exécutez les commandes dans le terminal.

Télécharger depuis le référentiel:

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

Ajouter un droit d'exercice:

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

Vérification de la version:

sudo docker-compose --version

Nous avons installé docker, maintenant il faut collecter une image. Pour ce faire, j'ai utilisé l'article du site Web de digitalocean: www.digitalocean.com/community/tutorials/how-to-set-up-laravel-nginx-and-mysql-with-docker-compose-ru . Il y aura une réimpression de cet article.

Téléchargement de Laravel et installation des dépendances

Dans un premier temps, nous téléchargeons la dernière version de Laravel et installons les dépendances du projet, y compris Composer, le gestionnaire de packages PHP au niveau de l'application. Nous installerons ces dépendances à l'aide de Docker afin de ne pas effectuer une installation globale de Composer.

Accédez à votre répertoire personnel et clonez la dernière version de Laravel dans un répertoire appelé laravel-app:

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

Accédez au répertoire laravel-app:

cd ~/laravel-app

Montez ensuite l'image Composer de Docker dans les répertoires dont vous avez besoin pour votre projet Laravel afin d'éviter la surcharge d'installation globale de Composer:

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

Les indicateurs -v et --rm de la commande docker run créent un conteneur virtuel qui se lie au répertoire actuel jusqu'à ce qu'il soit supprimé. Le contenu de votre répertoire ~ / laravel-app sera copié dans le conteneur, et le contenu du Composer créé dans le conteneur du dossier du fournisseur sera copié dans le répertoire actuel.

En conclusion, définissez le niveau d'autorisations dans le répertoire du projet afin qu'il appartienne à un utilisateur sans privilèges root:

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

Cela sera important lorsque vous écrivez le Dockerfile pour l'image de votre application, car cela vous permettra de travailler avec le code de l'application et de démarrer des processus dans le conteneur sans privilèges root.

Vous avez maintenant placé le code d'application et pouvez procéder à la définition des services à l'aide de Docker Compose.

La création d'un fichier Docker Compose La

création d'applications avec Docker Compose simplifie le processus de configuration et de versionnage dans votre infrastructure. Pour personnaliser notre application Laravel, nous allons créer un fichier docker-compose avec la définition des services du serveur web, de la base de données et de l'application.

Ouvrez le fichier:

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

Trois services sont définis dans le fichier docker-compose: app, webserver et db. Ajoutez le code suivant au fichier, tout en remplaçant le mot de passe root pour MYSQL_ROOT_PASSWORD, défini comme la variable d'environnement de service db, par un mot de passe de votre choix:

~/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

Les services suivants sont inclus ici:

application: cette définition de service contient l'application Laravel et lance l'image Docker personnalisée, digitalocean.com/php. Il définit également le paramètre working_dir dans le conteneur sur / var / www.
serveur Web: cette définition de service prend l'image nginx: alpine de Docker et ouvre les ports 80 et 443.
db: cette définition de service récupère l'image mysql: 5.7.22 de Docker et définit de nouvelles variables d'environnement, y compris la base de données laravel pour votre application et le mot de passe root pour la base de données. Vous pouvez utiliser n'importe quel nom de base de données que vous souhaitez, vous devez également remplacer votre_mysql_root_password par votre propre mot de passe fort. Cette définition de service mappe également le port hôte 3306 au port conteneur 3306.

Chaque propriété container_name définit un nom de conteneur correspondant au nom du service. Si vous ne définissez pas cette propriété, Docker donnera à chaque conteneur des noms composés du nom d'une personne historique et d'un mot aléatoire, séparés par un trait de soulignement.

Pour simplifier l'interaction entre les conteneurs, les services se connectent au réseau de connexion appelé app-network. Le réseau de connexion utilise un pont logiciel qui permet aux conteneurs connectés à ce réseau de communiquer entre eux. Le pilote de pont définit automatiquement les règles d'hôte afin que les conteneurs sur différents réseaux de connexion ne puissent pas communiquer directement entre eux. Cela améliore la sécurité des applications car seuls les services associés peuvent communiquer entre eux. Cela signifie également que vous pouvez spécifier différents réseaux et services qui se connectent aux fonctions associées: par exemple, les services d'application client peuvent utiliser le réseau frontal et les services serveur peuvent utiliser le réseau principal.

Voyons maintenant comment ajouter des volumes et lier des images montées aux définitions de service pour enregistrer de manière permanente les données d'application.

Stockage de données persistantes

Docker dispose de moyens puissants et pratiques pour le stockage de données persistantes. Dans notre application, nous utiliserons des volumes et des images montées pour enregistrer en permanence les fichiers de base de données, les applications et les configurations. Les volumes offrent une flexibilité de sauvegarde et une conservation à la fin du cycle de vie du conteneur, et les images montables montables facilitent la modification du code pendant le développement en reflétant immédiatement les modifications apportées aux fichiers ou répertoires hôtes dans les conteneurs. Nous utilisons les deux options.

Attention!

, , . , Docker . .

Définissez le volume nommé dbdata dans le fichier docker-compose dans la définition de service db pour conserver la base de données MySQL:

~/laravel-app/docker-compose.yml

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

Un volume nommé dbdata est utilisé pour enregistrer en permanence le contenu du dossier / var / lib / mysql à l'intérieur du conteneur. Cela vous permet d'arrêter et de redémarrer le service db sans perdre de données.
Ajoutez une définition de volume dbdata à la fin du fichier:

~/laravel-app/docker-compose.yml

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

Avec cette définition, vous pouvez utiliser ce volume pour différents services.

Ajoutez ensuite la liaison d'image de montage au service db pour les fichiers de configuration MySQL:

~/laravel-app/docker-compose.yml

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

Cette image montée lie le fichier ~ / laravel-app / mysql / my.cnf au répertoire /etc/mysql/my.cnf dans le conteneur.

Ajoutez ensuite les images montées au service du serveur Web. Il y en aura deux: un pour le code d'application et l'autre pour déterminer la configuration de Nginx

~/laravel-app/docker-compose.yml

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

La première image montée lie le code d'application dans le répertoire ~ / laravel-app au répertoire / var / www à l'intérieur du conteneur. Le fichier de configuration, ajouté à ~ / laravel-app / nginx / conf.d /, est également monté dans /etc/nginx/conf.d/ dans le conteneur, ce qui vous permet d'ajouter et de modifier le contenu du répertoire de configuration selon vos besoins.

En conclusion, ajoutez les montages d'images montés suivants au service d'application pour le code d'application et les fichiers de configuration:

~/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

Le service d'application lie l'image montée du dossier ~ / laravel-app, qui contient le code d'application, au dossier / var / www. Cela accélérera le processus de développement, car toute modification dans le répertoire de l'application locale sera immédiatement reflétée dans le conteneur. Vous liez également le fichier de configuration PHP ~ / laravel-app / php / local.ini au fichier /usr/local/etc/php/conf.d/local.ini dans le conteneur. Plus tard, vous créerez un fichier de configuration PHP local.

Votre fichier docker-compose ressemblera maintenant à ceci:

~/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

Création d'un Dockerfile

Docker vous permet de définir l'environnement à l'intérieur de conteneurs individuels à l'aide d'un Dockerfile. Dockerfile vous permet de créer des images personnalisées. qui peut être utilisé pour installer le logiciel d'application requis et modifier les paramètres selon les besoins. Vous pouvez transférer des images créées vers le Docker Hub ou tout registre privé.

Le Dockerfile sera situé dans le répertoire ~ / laravel-app. Créez un fichier:

nano ~/laravel-app/Dockerfile

Ce Dockerfile spécifiera l'image de base et les commandes et instructions nécessaires pour créer l'image de l'application Laravel. Ajoutez le code suivant au fichier:

~/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"]

Tout d'abord, le Dockerfile crée l'image au-dessus de l'image Docker php: 7.2-fpm. Il s'agit d'une image basée sur une instance installée de PHP FastCGI PHP-FPM. Ce fichier installe également les packages requis pour Laravel: mcrypt, pdo_mysql, mbstring et imagick with composer.

La directive RUN spécifie les commandes de mise à jour, d'installation et de configuration des paramètres à l'intérieur d'un conteneur, y compris un utilisateur dédié et un groupe nommé www. L'instruction WORKDIR définit le répertoire / var / www comme répertoire de travail de l'application.

La création d'un utilisateur et d'un groupe séparés avec des droits d'accès limités réduit la vulnérabilité lors du lancement de conteneurs Docker, qui s'exécutent par défaut avec les privilèges root. Au lieu d'exécuter ce conteneur avec les privilèges root, nous avons créé un utilisateur www avec des autorisations de lecture et d'écriture pour le dossier / var / www à l'aide de la commande COPY avec l'indicateur --chown pour copier les autorisations du dossier d'application.

La commande EXPOSE ouvre le port 9000 dans le conteneur du serveur php-fpm. CMD indique la commande qui doit être exécutée après la création du conteneur. Ici, CMD indique la commande php-fpm qui démarre le serveur.

Une fois les modifications terminées, enregistrez le fichier et fermez l'éditeur.

Vous pouvez maintenant passer à la définition de votre configuration PHP.

Configuration PHP

Vous avez défini l'infrastructure dans le fichier docker-compose, et vous pouvez maintenant configurer le service PHP pour qu'il agisse comme un processeur PHP pour les requêtes Nginx entrantes.

Pour configurer PHP, vous allez créer un fichier local.ini dans le dossier php. Il s'agit du fichier que vous avez lié au fichier /usr/local/etc/php/conf.d/local.ini dans le conteneur ci-dessus. La création de ce fichier vous permettra d'ignorer le fichier php.ini par défaut que PHP lit au démarrage.

Créez un répertoire php:

mkdir ~/laravel-app/php

Ouvrez ensuite le fichier local.ini:

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

Pour démontrer la configuration de PHP, nous ajouterons le code suivant pour définir les limites de taille de téléchargement de fichiers:

~/laravel-app/php/local.ini

upload_max_filesize=40M
post_max_size=40M

Les directives upload_max_filesize et post_max_size définissent la taille maximale autorisée des fichiers téléchargés et montrent comment définir les configurations php.ini à partir du fichier local.ini. Vous pouvez insérer tout paramètre de configuration PHP que vous souhaitez ignorer dans le fichier local.ini.

Configuration de Nginx

Lorsque vous configurez le service PHP, vous pouvez modifier le service Nginx pour utiliser PHP-FPM en tant que serveur FastCGI pour servir du contenu dynamique. Le serveur FastCGI est basé sur un protocole binaire pour l'interaction de programmes interactifs avec un serveur Web. Des informations supplémentaires peuvent être trouvées dans l'article «Comprendre et implémenter les proxys FastCGI dans Nginx».
Pour configurer Nginx, vous allez créer un fichier app.conf avec la configuration des services dans le dossier ~ / laravel-app / nginx / conf.d /.

Créez d'abord le répertoire nginx / conf.d /:

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

Créez ensuite le fichier de configuration app.conf:

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

Ajoutez le code suivant au fichier pour configurer Nginx:

~/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;
    }
}

Le bloc serveur configure le serveur Web Nginx à l'aide des directives suivantes:

listen: cette directive définit le port que le serveur écoute pour les requêtes entrantes.
error_log et access_log: ces directives définissent les fichiers de journalisation.
root: cette directive définit le chemin d'accès au dossier racine, formant le chemin d'accès complet pour tout fichier demandé dans le système de fichiers local.

Dans le bloc d'emplacement php, la directive fastcgi_pass indique que le service d'application écoute sur un socket TCP sur le port 9000. Avec lui, le serveur PHP-FPM écoute sur le réseau, pas sur le socket Unix. Bien que le socket Unix offre un léger avantage de vitesse par rapport au socket TCP, il n'a pas de protocole réseau et ignore la pile réseau. Dans les cas où les hôtes sont situés sur le même système, l'utilisation d'un socket Unix peut avoir un sens, mais si les services s'exécutent sur des hôtes différents, le socket TCP offre un avantage en vous permettant de vous connecter à des services distribués. Étant donné que nos conteneurs d'applications et de serveurs Web s'exécutent sur différents hôtes, il est plus efficace d'utiliser un socket TCP dans notre configuration.

Une fois les modifications terminées, enregistrez le fichier et fermez l'éditeur.

Grâce à la liaison créée précédemment, toute modification du dossier nginx / conf.d / est directement répercutée dans le conteneur du serveur Web.

Voyons maintenant les paramètres MySQL.

Configuration de MySQL

Après avoir configuré PHP et Nginx, vous pouvez activer MySQL comme base de données pour votre application.

Pour configurer MySQL, vous devez créer le fichier my.cnf dans le dossier mysql. Il s'agit du fichier que vous avez joint au fichier /etc/mysql/my.cnf à l'intérieur du conteneur lors de l'étape de configuration de la base de données. Le montage de l'image montée vous permet d'ignorer toutes les options my.cnf, si et quand cela est nécessaire.

Pour montrer comment cela fonctionne, nous allons ajouter des paramètres à my.cnf qui incluent le journal des demandes générales et définir le fichier journal.

Créez un répertoire mysql:

mkdir ~/laravel-app/mysql

Créez le fichier my.cnf:

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

Ajoutez le code suivant au fichier pour activer le journal des requêtes et définir l'emplacement du fichier journal:

~/laravel-app/mysql/my.cnf

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

Le fichier my.cnf prend en charge les journaux en définissant le paramètre general_log sur 1, ce qui active les journaux généraux. Le paramètre general_log_file spécifie où les journaux seront stockés.

Démarrage des conteneurs et modification des paramètres d'environnement

Vous avez défini tous les services dans le fichier docker-compose et créé des fichiers de configuration pour ces services. Vous pouvez maintenant exécuter des conteneurs. En conclusion, nous allons créer une copie du fichier .env.example que Laravel inclut par défaut et le nommer .env, car Laravel utilise un tel fichier pour déterminer l'environnement:

cp .env.example .env

Après avoir démarré les conteneurs, nous configurerons des paramètres d'installation spécifiques dans ce fichier.

Maintenant, tous vos services sont définis dans le fichier docker-compose, et il vous suffit d'exécuter une commande pour démarrer tous les conteneurs, créer des volumes et configurer et connecter des réseaux:

docker-compose up -d

La première fois que vous lancez docker-compose up, toutes les images Docker nécessaires seront téléchargées, ce qui peut prendre un certain temps. Après avoir téléchargé les images et les avoir enregistrées sur l'ordinateur local, Compose créera vos conteneurs. L'indicateur -d convertit le processus en un démon avec lequel les conteneurs continuent de s'exécuter en arrière-plan.

Une fois le processus terminé, utilisez la commande suivante pour répertorier tous les conteneurs en cours d'exécution:

docker ps

Vous verrez les résultats suivants avec des données sur les conteneurs d'application, de serveur Web et de base de données:

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

Dans ces résultats, l'ID CONTAINER est un identifiant unique pour chaque conteneur et NAMES répertorie les noms de service pour chaque conteneur. Vous pouvez utiliser ces deux identifiants pour accéder aux conteneurs. IMAGE définit le nom d'image de chaque conteneur et STATUS fournit des informations sur l'état du conteneur: démarré, redémarré ou arrêté.

Vous pouvez maintenant modifier le fichier .env dans le conteneur d'application pour ajouter des paramètres spécifiques à votre système.

Ouvrez le fichier avec docker-compose exec, qui vous permet d'exécuter des commandes spécifiques dans des conteneurs. Dans ce cas, vous ouvrez le fichier pour le modifier:

docker-compose exec app nano .env

Localisez le bloc spécifiant DB_CONNECTION et mettez-le à jour pour refléter la configuration de votre système. Vous allez modifier les champs suivants:

DB_HOST sera votre conteneur de base de données db.
DB_DATABASE sera la base de données laravel.
DB_USERNAME sera le nom d'utilisateur de votre base de données. Dans ce cas, nous utiliserons laraveluser.
DB_PASSWORD sera un mot de passe protégé pour ce compte d'utilisateur.

/var/www/.env

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

Il est également nécessaire de corriger les mêmes variables dans le fichier .env.example, car elles seront utilisées ultérieurement lors du déploiement sur le serveur.

Configurez ensuite la clé d'application pour Laravel avec la commande php artisan key: generate. Cette commande va générer une clé et la copier dans le fichier .env, qui protégera les sessions utilisateur et les données chiffrées:

docker-compose exec app php artisan key:generate

Vous disposez maintenant de tous les paramètres d'environnement nécessaires pour exécuter l'application. Pour mettre en cache ces paramètres dans un fichier qui accélère le chargement des applications, exécutez la commande:

docker-compose exec app php artisan config:cache

Les paramètres de configuration seront chargés dans le fichier /var/www/bootstrap/cache/config.php dans le conteneur.

Enfin, ouvrez le site localhost dans votre navigateur . La page principale de l'application Laravel s'ouvre.

Création d'un utilisateur MySQL

Lors de l'installation de MySQL, par défaut, seul un compte racine administratif est créé avec des privilèges illimités pour accéder au serveur de base de données. En règle générale, lorsque vous travaillez avec une base de données, il est préférable d'éviter d'utiliser un compte racine administratif. Au lieu de cela, nous allons créer un utilisateur de base de données spécial pour la base de données Laravel de notre application.
Pour créer un nouvel utilisateur, démarrez le shell interactif bash dans le conteneur db à l'aide de la commande docker-compose exec:

docker-compose exec db bash

Dans le conteneur, connectez-vous au compte administratif racine MySQL:

mysql -u root -p

Vous serez invité à entrer le mot de passe spécifié pour le compte racine MySQL lorsqu'il est installé dans le fichier docker-compose.

Tout d'abord, recherchez la base de données laravel définie dans le fichier docker-compose.
Exécutez la commande show databases pour vérifier les bases de données existantes:

show databases;

Dans les résultats, vous devriez voir la base de données laravel:

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

Créez ensuite un compte utilisateur qui sera autorisé à accéder à cette base de données.
Nous utilisons le nom d'utilisateur laraveluser, mais vous pouvez le remplacer par n'importe quel nom préféré. Assurez-vous simplement que le nom d'utilisateur et le mot de passe correspondent à ceux du fichier .env à l'étape précédente:

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

Mettre à jour les privilèges pour informer le serveur MySQL des changements:

FLUSH PRIVILEGES;

Fermez MySQL:

EXIT;

Quittez le conteneur:

exit

Vous pouvez maintenant effectuer la migration pour tester la base de données:

docker-compose exec app php artisan migrate

Les résultats de la confirmation de la migration sont les suivants:

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

Partie 2. Gitlab

Dans Hitlab, vous devez créer un nouveau projet.

Maintenant, nous devons enregistrer le projet dans le référentiel hitlab. Pour ce faire, appelez les commandes suivantes à partir du dossier de projet sur la machine locale:

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

Le projet doit apparaître dans Vue d'ensemble du projet -> Détails.
Pour faciliter l'obtention immédiate de l'environnement fini, nous enregistrons l'image d'ancrage de l'environnement dans le registre des listes de résultats.

Pour ce faire, vous devez faire:

docker login registry.gitlab.com

Et lancez l'image sur gitlab:

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

L'image sera située dans Packages-> Container Registry.

Pour terminer avec gitlab, nous obtenons immédiatement la clé de gitlab-runner. Pour ce faire, allez dans Paramètres-> CI / CD-> Runner. La clé se trouve à l'étape 3 de la section Configuration manuelle (Configurer manuellement un Runner spécifique).

Partie 3. Configuration du serveur

Le serveur VPS doit être pris avec le type de virtualisation KVM ou XEN. La virtualisation comme OpenVZ partage le cœur du système entre tous les utilisateurs, elle n'a donc pas la possibilité de modifier les paramètres du noyau. Pour le test, j'ai pris le serveur KVM avec Docker préinstallé. Cependant, il peut ne pas y avoir de docker sur le serveur. Dans ce cas, vous devez l'installer manuellement. L'algorithme est le même que lors de l'installation sur la machine locale. Il est également nécessaire de vérifier la version php. Pour Laravel, vous avez besoin d'au moins 7.2. J'ai également dû installer séparément l'extension pour php ext-mbstring (dans mon cas pour php 7.3):

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

Ensuite, nous devons installer gitlab-runner. Runner est un service qui acceptera un webhook d'une hitlab lors de la réception d'une nouvelle version et déploiera tout sur notre serveur.

Pour installer gitlab-runner, vous devez faire:

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

Après le téléchargement, définissez l'autorisation d'exécuter:

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

Ensuite, créez l'utilisateur gitlab-runner et exécutez le service gitlab runner:

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

Inscrire le coureur. Pour ce faire, nous avons besoin du jeton de la partie 2 de cet article:

sudo gitlab-runner register

En réponse, ils vous demanderont l'adresse de votre hitlab.

Spécifiez gitlab.com :

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

Ensuite, vous devez entrer le jeton. Entrez le jeton de la partie 2.

Please enter the gitlab-ci token for this runner
xxx

Ensuite, spécifiez une description et des balises séparées par des virgules. Ensuite, on nous propose de choisir un exécuteur testamentaire. Ici, vous devez sélectionner un shell:


Please enter the executor:
shell

Si je comprends bien, l'exécuteur est un environnement dans lequel le code du fichier .gitlab-ci.yml est exécuté. Vous avez le choix entre bash, ssh, docker, parallels, virtualbox et kubernets. La documentation recommande que si vous ne savez pas quoi utiliser, utilisez bash. Il s'agit d'une option universelle qui s'exécute sur la ligne de commande de votre serveur.

Ensuite, nous devons ajouter l'utilisateur gitlab-runner au groupe d'utilisateurs docker.

sudo usermod -aG docker gitlab-runner

Pour éviter les erreurs d'accès, ajoutez aux sudoers

sudo nano /etc/sudoers

ligne

gitlab-runner ALL=(ALL) NOPASSWD: ALL

Nous pouvons maintenant créer le fichier .gitlab-ci.yml. Il est nécessaire pour l'exécution du soi-disant Pipeline: une séquence de commandes pour déployer un projet.

Pour ce faire, accédez au référentiel de projet dans la liste des résultats et cliquez sur Créer un nouveau fichier. Gitlab lui-même proposera des modèles de fichiers, parmi lesquels vous devez sélectionner .gitlab-ci.yml. Après avoir créé un fichier dans gitlab, vous pouvez sélectionner un modèle pour le contenu du fichier. J'ai choisi laravel et l'ai refait un peu pour moi:


# 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

Après avoir exécuté avec succès le pipeline (CI / CD-> Pipelines) à l'adresse IP de votre serveur, vous devriez voir votre page laravel.

Pour configurer CI / CD, j'ai utilisé les instructions de Sean Bradley:

https://youtu.be/RV0845KmsNI

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

Laravel + Docker + Gitlab. Où commencer

Partie 1. Machine locale

Partie 2. Gitlab

Partie 3. Configuration du serveur

More articles: