🐫 ✏️ 🤛🏼 Laravel + Docker + Gitlab. Por onde começar 🤭 🦂 😜

Normalmente, eu sempre ficava sem uma janela de encaixe e achava que ela era necessária apenas para grandes projetos em grandes empresas. Mas um dia vi como uma janela de encaixe funciona em conjunto com o gitlab de um amigo e percebi que ainda deveria estudá-lo. No entanto, como geralmente acontece, não encontrei um artigo adequado - eles eram muito complexos ou incompletos ou estavam implícitos que todos sabem por si só. Eu tive que procurar várias fontes por um longo tempo, juntar tudo e, no final, consegui fazer um projeto simples e um CI / CD para ele.

Todo o trabalho pode ser dividido em três partes: na máquina local, no hitlab e no servidor.

Portanto, para a implementação do projeto, precisamos de uma conta gitlab e um servidor remoto com virtualização KVM ou XEN.

Parte 1. Máquina local

Na máquina local, você precisa instalar a janela de encaixe.

Comente

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

Para instalar em um ambiente Linux, você deve executar os seguintes comandos.

Exclua contêineres antigos:

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

Atualize o apt:

sudo apt-get update

Instale os seguintes pacotes para poder baixar a janela de encaixe do repositório via https:

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

Adicione a chave da janela de encaixe GPG oficial:

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

Verifique se a impressão está correta:

sudo apt-key fingerprint 0EBFCD88

Responda:

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]

Baixe a versão estável:

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

Atualize o apt novamente:

sudo apt-get update

Instale o mecanismo docker mais recente:

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

Verifique o funcionamento da janela de encaixe:

sudo docker run hello-world

Se tudo estiver correto, o download da imagem Hello World começará.

Instruções completas na documentação oficial da janela de encaixe .

Também precisamos instalar o docker-compose. A instrução oficial está aqui .

Para instalá-lo, execute os comandos no terminal.

Faça o download do repositório:

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

Adicionando um exercício certo:

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

Verificação de versão:

sudo docker-compose --version

Instalamos a janela de encaixe, agora é necessário coletar a imagem. Para fazer isso, usei o artigo do site digitalocean: www.digitalocean.com/community/tutorials/how-to-set-up-laravel-nginx-and-mysql-with-docker-compose-ru . Haverá uma reimpressão deste artigo.

Baixando o Laravel e instalando dependências

Na primeira etapa, baixamos a versão mais recente do Laravel e instalamos as dependências do projeto, incluindo o Composer, o gerenciador de pacotes PHP no nível do aplicativo. Instalaremos essas dependências usando o Docker para não executar uma instalação global do Composer.

Vá para o diretório inicial e clone a versão mais recente do Laravel em um diretório chamado laravel-app:

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

Vá para o diretório laravel-app:

cd ~/laravel-app

Em seguida, monte a imagem do compositor do Docker nos diretórios necessários para o seu projeto Laravel para evitar a sobrecarga de instalar o Composer globalmente:

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

Os sinalizadores -v e --rm do comando docker run criam um contêiner virtual que se liga ao diretório atual até que seja excluído. O conteúdo do diretório ~ / laravel-app será copiado para o contêiner e o conteúdo do Composer criado dentro do contêiner da pasta do fornecedor será copiado para o diretório atual.

Em conclusão, defina o nível de permissões no diretório do projeto para que ele pertença a um usuário sem privilégios de root:

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

Isso será importante quando você escrever o Dockerfile para a imagem do seu aplicativo, pois permitirá trabalhar com o código do aplicativo e iniciar processos no contêiner sem privilégios de root.

Agora você inseriu o código do aplicativo e pode prosseguir para a definição de serviços usando o Docker Compose.

A criação de

aplicativos Docker Compose para criação de arquivos com o Docker Compose simplifica o processo de configuração e controle de versão em sua infraestrutura. Para personalizar nosso aplicativo Laravel, criaremos um arquivo de composição de encaixe com a definição de serviços de servidor da web, banco de dados e aplicativo.

Abra o arquivo:

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

Três serviços são definidos no arquivo docker-compose: app, webserver e db. Adicione o seguinte código ao arquivo, enquanto substitui a senha raiz por MYSQL_ROOT_PASSWORD, definida como a variável de ambiente de serviço db, por uma senha de sua escolha:

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

Os seguintes serviços estão incluídos aqui:

app: essa definição de serviço contém o aplicativo Laravel e inicia a imagem personalizada do Docker, digitalocean.com/php. Ele também define o parâmetro working_dir no contêiner como / var / www.
servidor da web: essa definição de serviço pega a imagem nginx: alpine do Docker e abre as portas 80 e 443.
db: essa definição de serviço recupera a imagem mysql: 5.7.22 do Docker e define novas variáveis de ambiente, incluindo o banco de dados laravel para seu aplicativo e a senha raiz do banco de dados. Você pode usar qualquer nome de banco de dados que desejar; também deve substituir sua_mysql_root_password por sua própria senha forte. Essa definição de serviço também mapeia a porta 3306 do host para a porta 3306 do contêiner.

Cada propriedade container_name define um nome de container correspondente ao nome do serviço. Se você não definir essa propriedade, o Docker fornecerá a cada contêiner nomes que consistem no nome de uma pessoa histórica e em uma palavra aleatória, separados por um sublinhado.

Para simplificar a interação entre contêineres, os serviços se conectam à rede de conexão chamada app-network. A rede de conexão usa uma ponte de software que permite que os contêineres conectados a esta rede se comuniquem. O driver de ponte define automaticamente as regras do host para que os contêineres em diferentes redes de conexão não possam se comunicar diretamente entre si. Isso melhora a segurança do aplicativo, porque apenas serviços relacionados podem se comunicar. Isso também significa que você pode especificar redes e serviços diferentes que se conectam a funções relacionadas: por exemplo, serviços de aplicativos clientes podem usar a rede de front-end e serviços de servidor podem usar a rede de back-end.

Agora, vamos ver como adicionar volumes e vincular imagens montadas a definições de serviço para salvar permanentemente os dados do aplicativo.

Armazenamento de dados persistente O

Docker possui meios poderosos e convenientes para armazenamento de dados persistentes. Em nosso aplicativo, usaremos volumes e imagens montadas para salvar permanentemente arquivos, aplicativos e configurações do banco de dados. Os volumes fornecem flexibilidade e preservação de backup após o término do ciclo de vida do contêiner, e imagens montáveis montáveis simplificam as alterações de código durante o desenvolvimento, refletindo imediatamente as alterações nos arquivos ou diretórios de host nos contêineres. Usamos as duas opções.

Atenção!

, , . , Docker . .

Defina o volume denominado dbdata no arquivo docker-compose na definição de serviço db para manter o banco de dados MySQL:

~/laravel-app/docker-compose.yml

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

Um volume chamado dbdata é usado para salvar permanentemente o conteúdo da pasta / var / lib / mysql dentro do contêiner. Isso permite que você pare e reinicie o serviço db sem perder dados.
Adicione uma definição de volume dbdata no final do arquivo:

~/laravel-app/docker-compose.yml

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

Com esta definição, você pode usar este volume para diferentes serviços.

Em seguida, adicione a ligação da imagem de montagem ao serviço db para os arquivos de configuração do MySQL:

~/laravel-app/docker-compose.yml

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

Essa imagem montada vincula o arquivo ~ / laravel-app / mysql / my.cnf ao diretório /etc/mysql/my.cnf no contêiner.

Em seguida, adicione as imagens montadas ao serviço do servidor da web. Haverá dois: um para o código do aplicativo e outro para determinar a configuração do Nginx

~/laravel-app/docker-compose.yml

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

A primeira imagem montada vincula o código do aplicativo no diretório ~ / laravel-app ao diretório / var / www dentro do contêiner. O arquivo de configuração, adicionado a ~ / laravel-app / nginx / conf.d /, também é montado em /etc/nginx/conf.d/ no contêiner, o que permite adicionar e alterar o conteúdo do diretório de configuração, conforme necessário.

Em conclusão, adicione as seguintes montagens de imagens montadas ao serviço de aplicativo para obter códigos de aplicativo e arquivos de configuração:

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

O serviço de aplicativo vincula a imagem montada da pasta ~ / laravel-app, que contém o código do aplicativo, à pasta / var / www. Isso agilizará o processo de desenvolvimento, pois qualquer alteração no diretório local do aplicativo será refletida imediatamente no contêiner. Você também anexa o arquivo de configuração PHP ~ / laravel-app / php / local.ini ao arquivo /usr/local/etc/php/conf.d/local.ini no contêiner. Mais tarde, você criará um arquivo de configuração PHP local.

Seu arquivo docker-compose agora terá a seguinte aparência:

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

Criando um Dockerfile O

Docker permite definir o ambiente em contêineres individuais usando um Dockerfile. O Dockerfile permite criar imagens personalizadas. que pode ser usado para instalar o software aplicativo necessário e alterar as configurações conforme necessário. Você pode transferir imagens criadas para o Docker Hub ou qualquer registro particular.

O Dockerfile estará localizado no diretório ~ / laravel-app. Crie um arquivo:

nano ~/laravel-app/Dockerfile

Este Dockerfile especificará a imagem base e os comandos e instruções necessários para criar a imagem do aplicativo Laravel. Adicione o seguinte código ao arquivo:

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

Primeiro, o Dockerfile cria a imagem em cima da imagem do php: 7.2-fpm Docker. Esta é uma imagem baseada em uma instância instalada do PHP FastCGI PHP-FPM. Este arquivo também instala os pacotes necessários para o Laravel: mcrypt, pdo_mysql, mbstring e imagick com o compositor.

A diretiva RUN especifica comandos para atualizar, instalar e configurar parâmetros dentro de um contêiner, incluindo um usuário dedicado e um grupo chamado www. A instrução WORKDIR define o diretório / var / www como o diretório de trabalho do aplicativo.

Criar um usuário e grupo separados com direitos de acesso limitados reduz a vulnerabilidade ao iniciar os contêineres do Docker, que por padrão são executados com privilégios de root. Em vez de executar este contêiner com privilégios de root, criamos um usuário www com permissões de leitura e gravação para a pasta / var / www usando o comando COPY com o sinalizador --chown para copiar as permissões da pasta do aplicativo.

O comando EXPOSE abre a porta 9000 no contêiner para o servidor php-fpm. CMD indica o comando que deve ser executado após a criação do contêiner. Aqui, o CMD indica o comando php-fpm que inicia o servidor.

Quando terminar de fazer as alterações, salve o arquivo e feche o editor.

Agora você pode definir a sua configuração PHP.

Configuração do PHP

Você definiu a infraestrutura no arquivo docker-compose e agora pode configurar o serviço PHP para atuar como um processador PHP para solicitações Nginx recebidas.

Para configurar o PHP, você criará um arquivo local.ini na pasta php. Este é o arquivo que você vinculou ao arquivo /usr/local/etc/php/conf.d/local.ini no contêiner acima. Criar este arquivo permitirá que você ignore o arquivo php.ini padrão que o PHP lê na inicialização.

Crie um diretório php:

mkdir ~/laravel-app/php

Em seguida, abra o arquivo local.ini:

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

Para demonstrar a configuração do PHP, adicionaremos o seguinte código para definir os limites de tamanho de upload de arquivo:

~/laravel-app/php/local.ini

upload_max_filesize=40M
post_max_size=40M

As diretivas upload_max_filesize e post_max_size definem o tamanho máximo permitido dos arquivos enviados e mostram como definir as configurações do php.ini a partir do arquivo local.ini. Você pode inserir qualquer parâmetro de configuração do PHP que deseja ignorar no arquivo local.ini.

Configurando o Nginx

Ao configurar o serviço PHP, você pode modificar o serviço Nginx para usar o PHP-FPM como um servidor FastCGI para servir conteúdo dinâmico. O servidor FastCGI é baseado em um protocolo binário para a interação de programas interativos com um servidor da web. Informações adicionais podem ser encontradas no artigo “Compreendendo e implementando os proxies FastCGI no Nginx”.
Para configurar o Nginx, você criará um arquivo app.conf com a configuração de serviços na pasta ~ / laravel-app / nginx / conf.d /.

Primeiro, crie o diretório nginx / conf.d /:

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

Em seguida, crie o arquivo de configuração app.conf:

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

Adicione o seguinte código ao arquivo para configurar o 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;
    }
}

O bloco do servidor configura o servidor da web Nginx usando as seguintes diretivas:

listen: esta diretiva define a porta que o servidor atende às solicitações recebidas.
error_log e access_log: essas diretivas definem arquivos para log.
root: esta diretiva define o caminho para a pasta raiz, formando o caminho completo para qualquer arquivo solicitado no sistema de arquivos local.

No bloco de localização php, a diretiva fastcgi_pass indica que o serviço de aplicativo está escutando em um soquete TCP na porta 9000. Com ele, o servidor PHP-FPM escuta na rede, não no soquete Unix. Embora o soquete Unix ofereça uma ligeira vantagem de velocidade sobre o soquete TCP, ele não possui um protocolo de rede e ignora a pilha de rede. Nos casos em que os hosts estão localizados no mesmo sistema, o uso de um soquete Unix pode fazer sentido, mas se os serviços estiverem sendo executados em hosts diferentes, o soquete TCP oferece uma vantagem ao permitir a conexão com serviços distribuídos. Como nossos contêineres de aplicativos e servidores da web são executados em hosts diferentes, é mais eficiente usar um soquete TCP em nossa configuração.

Quando terminar de fazer as alterações, salve o arquivo e feche o editor.

Graças à ligação criada anteriormente, quaisquer alterações na pasta nginx / conf.d / são refletidas diretamente no contêiner do servidor da web.

Agora vamos ver os parâmetros do MySQL.

Configurando o MySQL

Após configurar o PHP e o Nginx, você pode ativar o MySQL como um banco de dados para seu aplicativo.

Para configurar o MySQL, você precisa criar o arquivo my.cnf na pasta mysql. Este é o arquivo que você anexou ao arquivo /etc/mysql/my.cnf dentro do contêiner durante a etapa de configuração do banco de dados. Montar a imagem montada permite ignorar qualquer opção my.cnf, se e quando necessário.

Para demonstrar como isso funciona, adicionaremos ao my.cnf configurações que incluem o log de solicitação geral e definiremos o arquivo de log.

Crie um diretório mysql:

mkdir ~/laravel-app/mysql

Crie o arquivo my.cnf:

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

Adicione o seguinte código ao arquivo para ativar o log de consulta e definir o local do arquivo de log:

~/laravel-app/mysql/my.cnf

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

O arquivo my.cnf suporta logs configurando o parâmetro general_log como 1, o que permite logs gerais. O parâmetro general_log_file especifica onde os logs serão armazenados.

Iniciando contêineres e alterando as configurações do ambiente

Você definiu todos os serviços no arquivo docker-compose e criou os arquivos de configuração para esses serviços. Agora você pode executar contêineres. Concluindo, criaremos uma cópia do arquivo .env.example que o Laravel inclui por padrão e o nomeará .env, pois o Laravel usa esse arquivo para determinar o ambiente:

cp .env.example .env

Depois de iniciar os contêineres, configuraremos parâmetros de instalação específicos neste arquivo.

Agora todos os seus serviços estão definidos no arquivo docker-compose, e você só precisa executar um comando para iniciar todos os contêineres, criar volumes e configurar e conectar redes:

docker-compose up -d

Na primeira vez que você inicia a composição do docker, todas as imagens necessárias do Docker serão baixadas, o que pode levar algum tempo. Depois de baixar as imagens e salvá-las no computador local, o Compose criará seus contêineres. O sinalizador -d converte o processo em um daemon com o qual os contêineres permanecem em execução em segundo plano.

Após a conclusão do processo, use o seguinte comando para listar todos os contêineres em execução:

docker ps

Você verá os seguintes resultados com dados nos contêineres de aplicativos, servidor da web e banco de dados:

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

Nesses resultados, o ID do CONTAINER é um identificador exclusivo para cada contêiner e NAMES lista os nomes de serviço para cada contêiner. Você pode usar esses dois identificadores para acessar contêineres. IMAGE define o nome da imagem de cada contêiner e STATUS fornece informações sobre o status do contêiner: iniciado, reiniciado ou parado.

Agora você pode modificar o arquivo .env no contêiner do aplicativo para adicionar parâmetros específicos ao seu sistema.

Abra o arquivo com o docker-compose exec, que permite executar comandos específicos em contêineres. Nesse caso, você abre o arquivo para edição:

docker-compose exec app nano .env

Localize o bloco que especifica DB_CONNECTION e atualize-o para refletir a configuração do sistema. Você alterará os seguintes campos:

DB_HOST será seu contêiner de banco de dados db.
DB_DATABASE será o banco de dados laravel.
DB_USERNAME será o nome de usuário do seu banco de dados. Nesse caso, usaremos laraveluser.
DB_PASSWORD será uma senha protegida para esta conta de usuário.

/var/www/.env

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

Também é necessário corrigir as mesmas variáveis no arquivo .env.example, pois ele será usado posteriormente ao implantar no servidor.

Em seguida, configure a chave do aplicativo para o Laravel com o comando php artisan key: generate. Este comando irá gerar uma chave e copiá-la para o arquivo .env, que protegerá as sessões do usuário e os dados criptografados:

docker-compose exec app php artisan key:generate

Agora você tem todas as configurações de ambiente necessárias para executar o aplicativo. Para armazenar em cache essas configurações em um arquivo que acelera o carregamento do aplicativo, execute o comando:

docker-compose exec app php artisan config:cache

As definições de configuração serão carregadas no arquivo /var/www/bootstrap/cache/config.php no contêiner.

Por fim, abra o site localhost no seu navegador . A página principal do aplicativo Laravel é aberta.

Criando um usuário MySQL

Ao instalar o MySQL, por padrão, apenas uma conta raiz administrativa é criada com privilégios ilimitados para acessar o servidor de banco de dados. Normalmente, ao trabalhar com um banco de dados, é melhor evitar o uso de uma conta raiz administrativa. Em vez disso, criaremos um usuário de banco de dados especial para o banco de dados Laravel do nosso aplicativo.
Para criar um novo usuário, inicie o shell interativo bash no contêiner db usando o comando docker-compose exec:

docker-compose exec db bash

Dentro do contêiner, efetue login na conta administrativa raiz do MySQL:

mysql -u root -p

Você será solicitado a digitar a senha especificada para a conta raiz do MySQL quando instalada no arquivo docker-compose.

Primeiro, verifique o banco de dados laravel definido no arquivo docker-compose.
Execute o comando show database para verificar os bancos de dados existentes:

show databases;

Nos resultados, você deve ver o banco de dados laravel:

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

Em seguida, crie uma conta de usuário que terá acesso permitido a este banco de dados.
Usamos o nome de usuário laraveluser, mas você pode substituí-lo por qualquer nome preferido. Apenas verifique se o nome de usuário e a senha correspondem aos do arquivo .env na etapa anterior:

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

Atualize os privilégios para notificar o servidor MySQL sobre alterações:

FLUSH PRIVILEGES;

Feche o MySQL:

EXIT;

Saia do contêiner:

exit

Agora você pode fazer a migração para testar o banco de dados:

docker-compose exec app php artisan migrate

Os resultados da confirmação da migração são os seguintes:

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

Um novo projeto deve ser criado no Hitlab.

Agora precisamos salvar o projeto no repositório do hitlab. Para fazer isso, chame os seguintes comandos da pasta do projeto na 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

O projeto deve aparecer em Visão geral do projeto -> Detalhes
Para facilitar a obtenção imediata do ambiente final, salvamos a imagem do docker do ambiente no registro da lista de ocorrências.

Para fazer isso, você deve fazer:

docker login registry.gitlab.com

E jogue a imagem no gitlab:

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

A imagem estará localizada em Packages-> Container Registry.Para

finalizar com o gitlab, obtemos imediatamente a chave para o gitlab-runner. Para fazer isso, vá para Configuração-> CI / CD-> Corredor. A chave está na etapa 3 na seção Configuração manual (configure manualmente um corredor específico).

Parte 3. Configuração do servidor

O servidor VPS deve ser utilizado com o tipo de virtualização KVM ou XEN. A virtualização como o OpenVZ compartilha o núcleo do sistema entre todos os usuários, portanto, não é possível alterar os parâmetros do kernel. Para o teste, fiz o servidor KVM com o Docker pré-instalado. No entanto, pode não haver uma janela de encaixe no servidor. Nesse caso, você deve instalá-lo manualmente. O algoritmo é o mesmo que ao instalar na máquina local. Também é necessário verificar a versão do php. Para o Laravel, você precisa de pelo menos 7.2. Eu também tive que instalar separadamente a extensão para php ext-mbstring (no meu caso para php 7.3):

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

Em seguida, precisamos instalar o gitlab-runner. O Runner é um serviço que aceita um webhook de um hitlab ao receber uma nova versão e implanta tudo em nosso servidor.

Para instalar o gitlab-runner, você precisa:

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

Após o download, defina a permissão para executar:

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

Em seguida, crie o usuário gitlab-runner e execute o serviço 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

Registre o corredor. Para fazer isso, precisamos do token da parte 2 deste artigo:

sudo gitlab-runner register

Em resposta, eles solicitarão o endereço do seu hitlab.

Especifique gitlab.com :

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

Em seguida, você precisa inserir o token. Digite o token da parte 2.

Please enter the gitlab-ci token for this runner
xxx

Em seguida, especifique uma descrição e tags separadas por vírgulas. Então, somos oferecidos a escolher um executor. Aqui você precisa selecionar um shell:


Please enter the executor:
shell

Pelo que entendi, o executor é um ambiente no qual o código do arquivo .gitlab-ci.yml é executado. Existem bash, ssh, janela de encaixe, paralelos, caixa virtual e kubernets à sua escolha. A documentação recomenda que, se você não souber o que usar, use o bash. Essa é uma opção universal que é executada na linha de comando do seu servidor.

Em seguida, precisamos adicionar o usuário gitlab-runner ao grupo de usuários do docker.

sudo usermod -aG docker gitlab-runner

Para evitar erros de acesso, adicione a sudoers

sudo nano /etc/sudoers

linha

gitlab-runner ALL=(ALL) NOPASSWD: ALL

Agora podemos criar o arquivo .gitlab-ci.yml. É necessário para a execução do chamado Pipeline: uma sequência de comandos para implantar um projeto.

Para fazer isso, acesse o repositório do projeto na lista de ocorrências e clique em Criar um novo arquivo. O próprio Gitlab oferecerá modelos de arquivo, entre eles, você deve selecionar .gitlab-ci.yml. Após criar um arquivo no gitlab, é possível selecionar um modelo para o conteúdo do arquivo. Eu escolhi o laravel e refiz um pouco para mim:


# 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

Depois de executar com êxito o pipeline (CI / CD-> Pipelines) no endereço IP do seu servidor, você deverá ver sua página laravel.

Para configurar o CI / CD, usei as instruções de Sean Bradley:

https://youtu.be/RV0845KmsNI

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

Laravel + Docker + Gitlab. Por onde começar

Parte 1. Máquina local

Parte 2. Gitlab

Parte 3. Configuração do servidor

More articles: