🚄 ❎ ➡️ Laravel + Docker + Gitlab. Dónde empezar 🥝 🤘🏿 🕰️

Por lo general, siempre prescindí de una ventana acoplable y pensé que solo se necesita para proyectos grandes en grandes empresas. Pero un día vi cómo funciona un acoplador junto con el gitlab de un amigo y me di cuenta de que aún debía estudiarlo. Sin embargo, como suele suceder, no encontré un artículo adecuado: eran demasiado complejos o incompletos, o implicaban que todos lo sabían por sí mismos. Tuve que buscar varias fuentes durante mucho tiempo, ponerlo todo junto y al final logré hacer un proyecto simple y CI / CD para ello.

Todo el trabajo se puede dividir en tres partes: en la máquina local, en el hitlab y en el servidor.

Entonces, para la implementación del proyecto, necesitamos una cuenta gitlab y un servidor remoto con virtualización KVM o XEN.

Parte 1. Máquina local

En la máquina local, debe instalar la ventana acoplable.

Comentario

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

Para instalar en un entorno Linux, debe ejecutar los siguientes comandos.

Eliminar contenedores viejos:

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

Actualizar apto:

sudo apt-get update

Instale los siguientes paquetes para poder descargar Docker desde el repositorio a través de https:

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

Agregue la clave de acoplamiento GPG oficial:

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

Asegúrese de que la impresión sea correcta:

sudo apt-key fingerprint 0EBFCD88

Responder:

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]

Descargar versión estable:

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

Actualice apt nuevamente:

sudo apt-get update

Instale el último motor acoplable:

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

Verifique la operación del acoplador:

sudo docker run hello-world

Si todo es correcto, comenzará la descarga de la imagen Hello World.

Instrucciones completas en la documentación oficial de la ventana acoplable .

También necesitamos instalar docker-compose. La instrucción oficial está aquí .

Para instalarlo, ejecute los comandos en la terminal.

Descargar desde el repositorio:

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

Agregar un ejercicio correcto:

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

Verificación de versión:

sudo docker-compose --version

Instalamos la ventana acoplable, ahora es necesario recopilar la imagen. Para hacer esto, utilicé el artículo del sitio web digitalocean: www.digitalocean.com/community/tutorials/how-to-set-up-laravel-nginx-and-mysql-with-docker-compose-ru . Habrá una reimpresión de este artículo.

Descarga de Laravel e instalación de dependencias

En el primer paso, descargamos la última versión de Laravel e instalamos las dependencias del proyecto, incluido Composer, el administrador de paquetes PHP a nivel de aplicación. Instalaremos estas dependencias usando Docker para no realizar una instalación global de Composer.

Vaya a su directorio de inicio y clone la última versión de Laravel en un directorio llamado laravel-app:

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

Vaya al directorio laravel-app:

cd ~/laravel-app

Luego monte la imagen del compositor de Docker en los directorios que necesita para su proyecto Laravel para evitar la sobrecarga de instalar Composer globalmente:

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

Los indicadores -v y --rm del comando docker run crean un contenedor virtual que se une al directorio actual hasta que se elimina. El contenido de su directorio ~ / laravel-app se copiará en el contenedor, y el contenido del Composer creado dentro del contenedor de la carpeta del proveedor se copiará en el directorio actual.

En conclusión, establezca el nivel de permisos en el directorio del proyecto para que sea propiedad de un usuario sin privilegios de root:

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

Esto será importante cuando escriba el Dockerfile para la imagen de su aplicación, ya que le permitirá trabajar con el código de la aplicación e iniciar procesos en el contenedor sin privilegios de root.

Ahora ha colocado el código de la aplicación y puede proceder a la definición de servicios utilizando Docker Compose.

Crear un archivo Docker Compose

Crear aplicaciones con Docker Compose simplifica el proceso de configuración y control de versiones en su infraestructura. Para personalizar nuestra aplicación Laravel, crearemos un archivo docker-compose con la definición de servicios de servidor web, base de datos y aplicación.

Abre el archivo:

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

Se definen tres servicios en el archivo docker-compose: aplicación, servidor web y db. Agregue el siguiente código al archivo, mientras reemplaza la contraseña de root para MYSQL_ROOT_PASSWORD, definida como la variable de entorno del servicio db, con una contraseña de su elección:

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

Aquí se incluyen los siguientes servicios:

aplicación: Esta definición de servicio contiene la aplicación Laravel y lanza la imagen Docker personalizada, digitalocean.com/php. También establece el parámetro working_dir en el contenedor en / var / www.
servidor web: esta definición de servicio toma la imagen nginx: alpine de Docker y abre los puertos 80 y 443.
db: esta definición de servicio recupera la imagen mysql: 5.7.22 de Docker y define nuevas variables de entorno, incluida la base de datos laravel para su aplicación y la contraseña raíz para la base de datos. Puede usar cualquier nombre de base de datos que desee, también debe reemplazar your_mysql_root_password con su propia contraseña segura. Esta definición de servicio también asigna el puerto de host 3306 al puerto de contenedor 3306.

Cada propiedad container_name define un nombre de contenedor correspondiente al nombre del servicio. Si no define esta propiedad, Docker le dará a cada contenedor nombres que consisten en el nombre de una persona histórica y una palabra aleatoria, separados por un guión bajo.

Para simplificar la interacción entre contenedores, los servicios se conectan a la red de conexión llamada app-network. La red de conexión utiliza un puente de software que permite que los contenedores conectados a esta red se comuniquen entre sí. El controlador de puente establece automáticamente las reglas de host para que los contenedores en diferentes redes de conexión no puedan comunicarse directamente entre sí. Esto mejora la seguridad de la aplicación porque solo los servicios relacionados pueden comunicarse entre sí. También significa que puede especificar diferentes redes y servicios que se conectan a funciones relacionadas: por ejemplo, los servicios de aplicaciones del cliente pueden usar la red frontend y los servicios del servidor pueden usar la red back-end.

Ahora, veamos cómo agregar volúmenes y vincular imágenes montadas a definiciones de servicio para guardar permanentemente los datos de la aplicación.

Almacenamiento persistente de datos

Docker tiene medios potentes y convenientes para el almacenamiento persistente de datos. En nuestra aplicación, utilizaremos volúmenes e imágenes montadas para guardar permanentemente archivos de bases de datos, aplicaciones y configuraciones. Los volúmenes proporcionan flexibilidad de copia de seguridad y preservación al finalizar el ciclo de vida del contenedor, y las imágenes montables montables simplifican los cambios de código durante el desarrollo al reflejar de inmediato los cambios en los archivos o directorios host en los contenedores. Usamos ambas opciones.

¡Advertencia!

, , . , Docker . .

Defina el volumen denominado dbdata en el archivo docker-compose en la definición del servicio db para conservar la base de datos MySQL:

~/laravel-app/docker-compose.yml

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

Un volumen llamado dbdata se usa para guardar permanentemente el contenido de la carpeta / var / lib / mysql dentro del contenedor. Esto le permite detener y reiniciar el servicio db sin perder datos.
Agregue una definición de volumen dbdata al final del archivo:

~/laravel-app/docker-compose.yml

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

Con esta definición, puede usar este volumen para diferentes servicios.

Luego agregue el enlace de imagen de montaje al servicio db para los archivos de configuración de MySQL:

~/laravel-app/docker-compose.yml

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

Esta imagen montada vincula el archivo ~ / laravel-app / mysql / my.cnf al directorio /etc/mysql/my.cnf en el contenedor.

Luego agregue las imágenes montadas al servicio del servidor web. Habrá dos: uno para el código de la aplicación y otro para determinar la configuración de Nginx

~/laravel-app/docker-compose.yml

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

La primera imagen montada vincula el código de la aplicación en el directorio ~ / laravel-app al directorio / var / www dentro del contenedor. El archivo de configuración, agregado a ~ / laravel-app / nginx / conf.d /, también está montado en /etc/nginx/conf.d/ en el contenedor, lo que le permite agregar y cambiar el contenido del directorio de configuración según sea necesario.

En conclusión, agregue los siguientes montajes de imágenes montadas al servicio de la aplicación para el código de la aplicación y los archivos de configuración:

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

El servicio de aplicaciones vincula la imagen montada de la carpeta ~ / laravel-app, que contiene el código de la aplicación, a la carpeta / var / www. Esto acelerará el proceso de desarrollo, ya que cualquier cambio en el directorio de la aplicación local se reflejará inmediatamente en el contenedor. También vincula el archivo de configuración PHP ~ / laravel-app / php / local.ini al archivo /usr/local/etc/php/conf.d/local.ini en el contenedor. Más tarde creará un archivo de configuración PHP local.

Su archivo docker-compose ahora se verá así:

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

Crear un Dockerfile

Docker le permite definir el entorno dentro de contenedores individuales utilizando un Dockerfile. Dockerfile le permite crear imágenes personalizadas. que puede usarse para instalar el software de aplicación requerido y cambiar la configuración según sea necesario. Puede transferir imágenes creadas al Docker Hub o cualquier registro privado.

El Dockerfile se ubicará en el directorio ~ / laravel-app. Crea un archivo:

nano ~/laravel-app/Dockerfile

Este Dockerfile especificará la imagen base y los comandos e instrucciones necesarios para construir la imagen de la aplicación Laravel. Agregue el siguiente código al archivo:

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

Primero, el Dockerfile crea la imagen encima de la imagen de Docker php: 7.2-fpm. Esta es una imagen basada en una instancia instalada de PHP FastCGI PHP-FPM. Este archivo también instala los paquetes necesarios para Laravel: mcrypt, pdo_mysql, mbstring e imagick with composer.

La directiva RUN especifica comandos para actualizar, instalar y configurar parámetros dentro de un contenedor, incluido un usuario dedicado y un grupo llamado www. La instrucción WORKDIR establece el directorio / var / www como el directorio de trabajo de la aplicación.

Crear un usuario y un grupo separados con derechos de acceso limitados reduce la vulnerabilidad al iniciar contenedores Docker, que de forma predeterminada se ejecutan con privilegios de root. En lugar de ejecutar este contenedor con privilegios de root, creamos un usuario www con permisos de lectura y escritura para la carpeta / var / www usando el comando COPY con el indicador --chown para copiar los permisos de la carpeta de la aplicación.

El comando EXPOSE abre el puerto 9000 en el contenedor para el servidor php-fpm. CMD indica el comando que debe ejecutarse después de crear el contenedor. Aquí, CMD indica el comando php-fpm que inicia el servidor.

Cuando termine de hacer cambios, guarde el archivo y cierre el editor.

Ahora puede pasar a definir su configuración de PHP.

Configuración de PHP

Ha definido la infraestructura en el archivo docker-compose, y ahora puede configurar el servicio PHP para que actúe como un procesador PHP para las solicitudes entrantes de Nginx.

Para configurar PHP, creará un archivo local.ini en la carpeta php. Este es el archivo que ha vinculado al archivo /usr/local/etc/php/conf.d/local.ini en el contenedor de arriba. La creación de este archivo le permitirá ignorar el archivo php.ini predeterminado que PHP lee en el inicio.

Crea un directorio php:

mkdir ~/laravel-app/php

Luego abra el archivo local.ini:

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

Para demostrar la configuración de PHP, agregaremos el siguiente código para establecer los límites de tamaño de carga de archivos:

~/laravel-app/php/local.ini

upload_max_filesize=40M
post_max_size=40M

Las directivas upload_max_filesize y post_max_size establecen el tamaño máximo permitido de los archivos cargados y muestran cómo configurar las configuraciones de php.ini desde el archivo local.ini. Puede insertar cualquier parámetro de configuración de PHP que desee ignorar en el archivo local.ini.

Configuración de Nginx

Cuando configura el servicio PHP, puede modificar el servicio Nginx para usar PHP-FPM como un servidor FastCGI para servir contenido dinámico. El servidor FastCGI se basa en un protocolo binario para la interacción de programas interactivos con un servidor web. Se puede encontrar información adicional en el artículo "Comprensión e implementación de proxies FastCGI en Nginx".
Para configurar Nginx, creará un archivo app.conf con la configuración de servicios en la carpeta ~ / laravel-app / nginx / conf.d /.

Primero cree el directorio nginx / conf.d /:

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

Luego cree el archivo de configuración app.conf:

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

Agregue el siguiente código al archivo para configurar 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;
    }
}

El bloque de servidor configura el servidor web Nginx usando las siguientes directivas:

listen: esta directiva define el puerto que el servidor escucha para las solicitudes entrantes.
error_log y access_log: estas directivas definen archivos para el registro.
root: esta directiva establece la ruta a la carpeta raíz, formando la ruta completa para cualquier archivo solicitado en el sistema de archivos local.

En el bloque de ubicación php, la directiva fastcgi_pass indica que el servicio de la aplicación está escuchando en un socket TCP en el puerto 9000. Con él, el servidor PHP-FPM escucha en la red, no en el socket Unix. Aunque el socket Unix proporciona una ligera ventaja de velocidad sobre el socket TCP, no tiene un protocolo de red y omite la pila de red. En los casos en que los hosts se encuentran en el mismo sistema, puede tener sentido usar un socket Unix, pero si los servicios se ejecutan en diferentes hosts, el socket TCP proporciona una ventaja al permitirle conectarse a servicios distribuidos. Dado que nuestros contenedores de aplicaciones y servidores web se ejecutan en diferentes hosts, es más eficiente usar un socket TCP en nuestra configuración.

Cuando termine de hacer cambios, guarde el archivo y cierre el editor.

Gracias al enlace creado anteriormente, cualquier cambio en la carpeta nginx / conf.d / se refleja directamente en el contenedor del servidor web.

Ahora veamos los parámetros de MySQL.

Configuración de MySQL

Después de configurar PHP y Nginx, puede activar MySQL como una base de datos para su aplicación.

Para configurar MySQL, debe crear el archivo my.cnf en la carpeta mysql. Este es el archivo que adjuntó al archivo /etc/mysql/my.cnf dentro del contenedor durante el paso de configuración de la base de datos. Montar la imagen montada le permite ignorar cualquier opción my.cnf, si es necesario.

Para demostrar cómo funciona esto, agregaremos configuraciones a my.cnf que incluyen el registro de solicitud general y configuraremos el archivo de registro.

Crea un directorio mysql:

mkdir ~/laravel-app/mysql

Cree el archivo my.cnf:

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

Agregue el siguiente código al archivo para activar el registro de consultas y establezca la ubicación del archivo de registro:

~/laravel-app/mysql/my.cnf

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

El archivo my.cnf admite registros al establecer el parámetro general_log en 1, que habilita los registros generales. El parámetro general_log_file especifica dónde se almacenarán los registros.

Inicio de contenedores y cambio de la configuración del entorno

Definió todos los servicios en el archivo docker-compose y creó archivos de configuración para estos servicios. Ahora puedes ejecutar contenedores. En conclusión, crearemos una copia del archivo .env.example que Laravel incluye por defecto y lo llamaremos .env, ya que Laravel usa dicho archivo para determinar el entorno:

cp .env.example .env

Después de iniciar los contenedores, configuraremos parámetros de instalación específicos en este archivo.

Ahora todos sus servicios están definidos en el archivo docker-compose, y solo necesita ejecutar un comando para iniciar todos los contenedores, crear volúmenes y configurar y conectar redes:

docker-compose up -d

La primera vez que inicie Docker-compose, se descargarán todas las imágenes Docker necesarias, lo que puede llevar algún tiempo. Después de descargar las imágenes y guardarlas en la computadora local, Compose creará sus contenedores. El indicador -d convierte el proceso en un demonio con el que los contenedores permanecen ejecutándose en segundo plano.

Una vez que se complete el proceso, use el siguiente comando para enumerar todos los contenedores en ejecución:

docker ps

Verá los siguientes resultados con datos sobre la aplicación, el servidor web y los contenedores db:

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

En estos resultados, la ID DE CONTENEDOR es un identificador único para cada contenedor, y NAMES enumera los nombres de servicio para cada contenedor. Puede usar ambos identificadores para acceder a los contenedores. IMAGE define el nombre de la imagen de cada contenedor, y STATUS proporciona información sobre el estado del contenedor: iniciado, reiniciado o detenido.

Ahora puede modificar el archivo .env en el contenedor de la aplicación para agregar parámetros específicos a su sistema.

Abra el archivo con docker-compose exec, que le permite ejecutar comandos específicos en contenedores. En este caso, abre el archivo para editarlo:

docker-compose exec app nano .env

Localice el bloque que especifica DB_CONNECTION y actualícelo para reflejar la configuración de su sistema. Cambiarás los siguientes campos:

DB_HOST será su contenedor de base de datos db.
DB_DATABASE será la base de datos laravel.
DB_USERNAME será el nombre de usuario para su base de datos. En este caso, usaremos laraveluser.
DB_PASSWORD será una contraseña protegida para esta cuenta de usuario.

/var/www/.env

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

También es necesario corregir las mismas variables en el archivo .env.example, ya que se utilizará más adelante cuando se implemente en el servidor.

Luego configure la clave de aplicación para Laravel con la clave php artisan: generate command. Este comando generará una clave y la copiará al archivo .env, que protegerá las sesiones de usuario y los datos cifrados:

docker-compose exec app php artisan key:generate

Ahora tiene todas las configuraciones de entorno necesarias para ejecutar la aplicación. Para almacenar en caché estas configuraciones en un archivo que acelere la carga de la aplicación, ejecute el comando:

docker-compose exec app php artisan config:cache

La configuración se cargará en el archivo /var/www/bootstrap/cache/config.php en el contenedor.

Finalmente, abra el sitio localhost en su navegador . Se abre la página principal de la aplicación Laravel.

Creación de un usuario MySQL

Al instalar MySQL, de manera predeterminada solo se crea una cuenta raíz administrativa con privilegios ilimitados para acceder al servidor de la base de datos. Cuando se trabaja con una base de datos, generalmente es mejor evitar el uso de una cuenta raíz administrativa. En su lugar, crearemos un usuario de base de datos especial para la base de datos Laravel de nuestra aplicación.
Para crear un nuevo usuario, inicie el shell interactivo bash en el contenedor db usando el comando docker-compose exec:

docker-compose exec db bash

Dentro del contenedor, inicie sesión en la cuenta administrativa raíz de MySQL:

mysql -u root -p

Se le pedirá que ingrese la contraseña especificada para la cuenta raíz de MySQL cuando esté instalada en el archivo docker-compose.

Primero, verifique la base de datos laravel definida en el archivo docker-compose.
Ejecute el comando show bases de datos para verificar las bases de datos existentes:

show databases;

En los resultados, debería ver la base de datos laravel:

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

Luego cree una cuenta de usuario que tendrá acceso a esta base de datos.
Usamos el nombre de usuario laraveluser, pero puede reemplazarlo con cualquier nombre preferido. Solo asegúrese de que el nombre de usuario y la contraseña coincidan con los del archivo .env en el paso anterior:

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

Privilegios de actualización para notificar cambios al servidor MySQL:

FLUSH PRIVILEGES;

Cerrar MySQL:

EXIT;

Salir del contenedor:

exit

Ahora puede hacer la migración para probar la base de datos:

docker-compose exec app php artisan migrate

Los resultados de la confirmación de la migración son los siguientes:

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

Parte 2. Gitlab

En Hitlab, debe crear un nuevo proyecto.

Ahora necesitamos guardar el proyecto en el repositorio de hitlab. Para hacer esto, llame a los siguientes comandos desde la carpeta del proyecto en la máquina local:

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

El proyecto debe aparecer en Descripción general del proyecto -> Detalles.
Para que sea conveniente obtener de inmediato el entorno terminado, guardamos la imagen acoplable del entorno en el registro de la lista de resultados.

Para hacer esto, debes hacer:

docker login registry.gitlab.com

Y arroja la imagen en gitlab:

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

La imagen se ubicará en Paquetes-> Registro de contenedores.

Para finalizar con gitlab, obtenemos inmediatamente la clave para gitlab-runner. Para hacer esto, vaya a Configuración-> CI / CD-> Runner. La clave se encuentra en el paso 3 en la sección Configuración manual (Configurar un Runner específico manualmente).

Parte 3. Configuración del servidor

El servidor VPS debe tomarse con el tipo de virtualización KVM o XEN. La virtualización como OpenVZ comparte el núcleo del sistema entre todos los usuarios, por lo que no tiene la capacidad de cambiar los parámetros del kernel. Para la prueba, tomé el servidor KVM con Docker preinstalado. Sin embargo, puede que no haya una ventana acoplable en el servidor. En este caso, debe instalarlo manualmente. El algoritmo es el mismo que cuando se instala en la máquina local. También es necesario verificar la versión de php. Para Laravel necesitas al menos 7.2. También tuve que instalar por separado la extensión para php ext-mbstring (en mi caso para php 7.3):

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

A continuación, necesitamos instalar gitlab-runner. Runner es un servicio que aceptará un webhook de un hitlab al recibir una nueva versión y desplegará todo en nuestro servidor.

Para instalar gitlab-runner debes hacer:

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

Después de la descarga, configure el permiso para ejecutar:

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

A continuación, cree el usuario gitlab-runner y ejecute el servicio 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

Registrarse corredor. Para hacer esto, necesitamos el token de la parte 2 de este artículo:

sudo gitlab-runner register

En respuesta, le pedirán la dirección de su hitlab.

Especifique gitlab.com :

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

A continuación, debe ingresar el token. Ingrese el token de la parte 2.

Please enter the gitlab-ci token for this runner
xxx

A continuación, especifique una descripción y etiquetas separadas por comas. Entonces se nos ofrece elegir un albacea. Aquí debe seleccionar un shell:


Please enter the executor:
shell

Según tengo entendido, el ejecutor es un entorno en el que se ejecuta el código del archivo .gitlab-ci.yml. Hay bash, ssh, docker, paralelos, virtualbox y kubernets para elegir. La documentación recomienda que si no sabe qué usar, use bash. Esta es una opción universal que se ejecuta en la línea de comandos de su servidor.

Luego necesitamos agregar el usuario gitlab-runner al grupo de usuarios de docker.

sudo usermod -aG docker gitlab-runner

Para evitar errores de acceso, agregue a sudoers

sudo nano /etc/sudoers

línea

gitlab-runner ALL=(ALL) NOPASSWD: ALL

Ahora podemos crear el archivo .gitlab-ci.yml. Es necesario para la ejecución del llamado Pipeline: una secuencia de comandos para implementar un proyecto.

Para hacer esto, vaya al repositorio del proyecto en la lista de resultados y haga clic en Crear un nuevo archivo. El propio Gitlab ofrecerá plantillas de archivos, entre ellas debe seleccionar .gitlab-ci.yml. Después de crear un archivo en el gitlab, es posible seleccionar una plantilla para el contenido del archivo. Elegí laravel y lo rehice un poco para mí:


# 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

Después de ejecutar con éxito la canalización (CI / CD-> Canalizaciones) en la dirección IP de su servidor, debería ver su página laravel.

Para configurar CI / CD, utilicé las instrucciones de Sean Bradley:

https://youtu.be/RV0845KmsNI

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

Laravel + Docker + Gitlab. Dónde empezar

Parte 1. Máquina local

Parte 2. Gitlab

Parte 3. Configuración del servidor

More articles: