Jak nainstalovat a nastavit Laravel pomocí Docker Compose na Ubuntu 22.04

Úvod

Chcete-li kontejnerovat aplikace označuje proces přizpůsobení aplikace a jejích komponent, aby bylo možné ji spouštět v odlehčených prostředích známých jako kontejnery. Taková prostředí jsou izolovaná a na jedno použití a lze je využít pro vývoj, testování a nasazování aplikací do produkce.

V této příručce použijeme Docker Compose ke kontejnerizaci aplikace Laravel pro vývoj. Až budete hotovi, budete mít ukázkovou aplikaci Laravel spuštěnou na třech samostatných kontejnerech služeb:

• app služba běžící na PHP7.4-FPM;
• A db služba běžící na MySQL 5.7;
• nginx službu, která používá app služba pro analýzu kódu PHP před doručením aplikace Laravel konečnému uživateli.

Abychom umožnili efektivnější vývojový proces a usnadnili ladění aplikací, budeme udržovat soubory aplikací synchronizované pomocí sdílených svazků. Také uvidíme, jak používat docker-compose exec příkazy ke spuštění Composer a Artisan v app kontejner.

Předpoklady

• Přístup k místnímu počítači nebo vývojovému serveru Ubuntu 22.04 jako uživatel bez oprávnění root s právy sudo. Pokud používáte vzdálený server, je vhodné mít nainstalovaný aktivní firewall. Chcete-li je nastavit, nahlédněte do našeho Průvodce počátečním nastavením serveru pro Ubuntu 22.04.
• Docker nainstalovaný na vašem serveru podle kroků 1 a 2 postupu Jak nainstalovat a používat Docker na Ubuntu 22.04.
• Docker Compose nainstalovaný na vašem serveru podle kroku 1 Jak nainstalovat a používat Docker Compose na Ubuntu 22.04.

Krok 1 — Získání ukázkové aplikace

Pro začátek stáhneme demo aplikaci Laravel z jejího úložiště Github. Zajímá nás tutorial-01 větev, která obsahuje základní aplikaci Laravel, kterou jsme vytvořili v prvním průvodci této série.

Chcete-li získat kód aplikace, který je kompatibilní s tímto výukovým programem, stáhněte si verzi tutorial-1.0.1 do vašeho domovského adresáře pomocí:

cd ~
curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-1.0.1.zip -o travellist.zip

Budeme potřebovat unzip příkaz k rozbalení kódu aplikace. V případě, že jste tento balíček ještě nenainstalovali, učiňte tak nyní pomocí:

sudo apt update
sudo apt install unzip

Nyní rozbalte obsah aplikace a přejmenujte rozbalený adresář pro snazší přístup:

unzip travellist.zip
mv travellist-laravel-demo-tutorial-1.0.1 travellist-demo

Přejděte na travellist-demo adresář:

cd travellist-demo

V dalším kroku vytvoříme .env konfigurační soubor pro nastavení aplikace.

Krok 2 – Nastavení .env aplikace Soubor

Konfigurační soubory Laravel jsou umístěny v adresáři s názvem config , v kořenovém adresáři aplikace. Navíc .env se používá k nastavení konfigurace závislé na prostředí, jako jsou přihlašovací údaje a jakékoli informace, které se mohou mezi nasazeními lišit. Tento soubor není součástí kontroly revizí.

Upozornění :Konfigurační soubor prostředí obsahuje citlivé informace o vašem serveru, včetně přihlašovacích údajů k databázi a bezpečnostních klíčů. Z tohoto důvodu byste tento soubor nikdy neměli sdílet veřejně.

Hodnoty obsažené v .env bude mít přednost před hodnotami nastavenými v běžných konfiguračních souborech umístěných v config adresář. Každá instalace v novém prostředí vyžaduje přizpůsobený soubor prostředí, který definuje věci, jako je nastavení připojení k databázi, možnosti ladění, adresa URL aplikace a další položky, které se mohou lišit v závislosti na prostředí, ve kterém aplikace běží.

Nyní vytvoříme nový .env k přizpůsobení možností konfigurace pro vývojové prostředí, které nastavujeme. Laravel přichází s příkladem .env soubor, který můžeme zkopírovat a vytvořit si vlastní:

cp .env.example .env

Otevřete tento soubor pomocí nano nebo vámi zvolený textový editor:

nano .env

Aktuální .env soubor z travellist demo aplikace obsahuje nastavení pro použití místní databáze MySQL s 127.0.0.1 jako hostitel databáze. Potřebujeme aktualizovat DB_HOST proměnnou tak, aby ukazovala na databázovou službu, kterou vytvoříme v našem prostředí Docker. V této příručce budeme naši databázovou službu nazývat db . Pokračujte a nahraďte uvedenou hodnotu DB_HOST s názvem databázové služby:

.env

APP_NAME=Travellist
APP_ENV=dev
APP_KEY=
APP_DEBUG=true
APP_URL=http://localhost:8000

LOG_CHANNEL=stack

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=travellist
DB_USERNAME=travellist_user
DB_PASSWORD=password
...

Pokud si přejete, můžete také změnit název databáze, uživatelské jméno a heslo. Tyto proměnné využijeme v dalším kroku, kde nastavíme docker-compose.yml soubor pro konfiguraci našich služeb.

Po dokončení úprav soubor uložte. Pokud jste použili nano , můžete to provést stisknutím Ctrl+x a poté Y a Enter pro potvrzení.

Krok 3 – Nastavení Dockerfile aplikace

Přestože naše služby MySQL i Nginx budou založeny na výchozích obrázcích získaných z Docker Hub, stále musíme vytvořit vlastní bitovou kopii pro aplikační kontejner. Vytvoříme pro to nový Dockerfile.

Náš cestovatel obrázek bude založen na php:7.4-fpm oficiální obrázek PHP z Docker Hub. Kromě tohoto základního prostředí PHP-FPM nainstalujeme několik dalších modulů PHP a nástroj pro správu závislostí Composer.

Vytvoříme také nového uživatele systému; to je nutné ke spuštění artisan a composer příkazy při vývoji aplikace. uid nastavení zajišťuje, že uživatel v kontejneru má stejné uid jako váš systémový uživatel na vašem hostitelském počítači, kde používáte Docker. Tímto způsobem jsou všechny soubory vytvořené těmito příkazy replikovány v hostiteli se správnými oprávněními. To také znamená, že budete moci použít svůj vybraný editor kódu v hostitelském počítači k vývoji aplikace, která běží uvnitř kontejnerů.

Vytvořte nový Dockerfile pomocí:

nano Dockerfile

Zkopírujte následující obsah do vašeho Dockerfile:

Dockerfile

FROM php:7.4-fpm

# Arguments defined in docker-compose.yml
ARG user
ARG uid

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

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

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Create system user to run Composer and Artisan Commands
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Set working directory
WORKDIR /var/www

USER $user

Až budete hotovi, nezapomeňte soubor uložit.

Náš Dockerfile začíná definováním základního obrázku, který používáme:php:7.4-fpm .

Po instalaci systémových balíčků a rozšíření PHP nainstalujeme Composer zkopírováním composer spustitelný z jeho nejnovějšího oficiálního obrazu do našeho vlastního obrazu aplikace.

Poté je vytvořen a nastaven nový systémový uživatel pomocí user a uid argumenty, které byly deklarovány na začátku souboru Dockerfile. Tyto hodnoty vloží Docker Compose při sestavení.

Nakonec nastavíme výchozí pracovní adresář jako /var/www a změnit na nově vytvořeného uživatele. Tím zajistíte, že se při spuštění composer připojujete jako běžný uživatel a že jste ve správném adresáři a artisan příkazy na kontejneru aplikace.

Krok 4 – Nastavení konfigurace Nginx a souborů výpisu databáze

Při vytváření vývojových prostředí pomocí Docker Compose je často nutné sdílet konfigurační nebo inicializační soubory s kontejnery služeb, aby bylo možné tyto služby nastavit nebo zavést. Tento postup usnadňuje provádění změn v konfiguračních souborech za účelem doladění vašeho prostředí během vývoje aplikace.

Nyní nastavíme složku se soubory, které budou použity ke konfiguraci a inicializaci našich servisních kontejnerů.

Pro nastavení Nginx budeme sdílet travellist.conf soubor, který nakonfiguruje způsob obsluhy aplikace. Vytvořte docker-compose/nginx složka s:

mkdir -p docker-compose/nginx

Otevřete nový soubor s názvem travellist.conf v tomto adresáři:

nano docker-compose/nginx/travellist.conf

Do tohoto souboru zkopírujte následující konfiguraci Nginx:

docker-compose/nginx/travellist.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;
    }
}

Tento soubor nakonfiguruje Nginx tak, aby naslouchal na portu 80 a použijte index.php jako výchozí indexovou stránku. Kořen dokumentu nastaví na /var/www/public a poté nakonfigurujte Nginx tak, aby používal app službu na portu 9000 zpracovat *.php soubory.

Po dokončení úprav soubor uložte a zavřete.

Abychom mohli nastavit databázi MySQL, budeme sdílet výpis databáze, který bude importován při inicializaci kontejneru. Toto je funkce poskytovaná obrazem MySQL 5.7, který budeme v tomto kontejneru používat.

Vytvořte novou složku pro své inicializační soubory MySQL v docker-compose složka:

mkdir docker-compose/mysql

Otevřete nový .sql soubor:

nano docker-compose/mysql/init_db.sql

Následující výpis MySQL je založen na databázi, kterou jsme vytvořili v našem průvodci Laravel on LEMP. Vytvoří novou tabulku s názvem places . Poté vyplní tabulku sadou vzorových míst.

Přidejte do souboru následující kód:

docker-compose/mysql/db_init.sql

DROP TABLE IF EXISTS `places`;

CREATE TABLE `places` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
  `visited` tinyint(1) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

INSERT INTO `places` (name, visited) VALUES ('Berlin',0),('Budapest',0),('Cincinnati',1),('Denver',0),('Helsinki',0),('Lisbon',0),('Moscow',1),('Nairobi',0),('Oslo',1),('Rio',0),('Tokyo',0);

places tabulka obsahuje tři pole:id , name a visited . visited pole je příznak používaný k identifikaci míst, která ještě zbývá navštívit . Neváhejte změnit ukázková místa nebo přidat nová. Až budete hotovi, uložte a zavřete soubor.

Dokončili jsme nastavení Dockerfile aplikace a konfiguračních souborů služby. Dále nastavíme Docker Compose, aby tyto soubory používal při vytváření našich služeb.

Krok 5 — Vytvoření prostředí s více kontejnery pomocí Docker Compose

Docker Compose vám umožňuje vytvářet prostředí s více kontejnery pro aplikace běžící na Dockeru. Používá definice služeb vytvářet plně přizpůsobitelná prostředí s více kontejnery, které mohou sdílet sítě a objemy dat. To umožňuje bezproblémovou integraci mezi komponentami aplikace.

Abychom mohli nastavit definice našich služeb, vytvoříme nový soubor s názvem docker-compose.yml . Tento soubor se obvykle nachází v kořenovém adresáři složky aplikace a definuje vaše kontejnerové prostředí, včetně základních obrázků, které použijete k sestavení kontejnerů, a toho, jak budou vaše služby interagovat.

V našem docker-compose.yml definujeme tři různé služby soubor:app , db a nginx .

app služba vytvoří obrázek s názvem travellist , na základě Dockerfile, který jsme dříve vytvořili. Kontejner definovaný touto službou spustí php-fpm serveru analyzovat kód PHP a odeslat výsledky zpět do nginx služba, která poběží na samostatném kontejneru. mysql definuje kontejner, na kterém běží server MySQL 5.7. Naše služby budou sdílet mostovou síť s názvem travellist .

Soubory aplikace budou synchronizovány v app a nginx služby prostřednictvím vázat připojení . Bind mounts jsou užitečné ve vývojových prostředích, protože umožňují výkonnou obousměrnou synchronizaci mezi hostitelským počítačem a kontejnery.

Vytvořte nový docker-compose.yml soubor v kořenovém adresáři složky aplikace:

nano docker-compose.yml

Typický docker-compose.yml soubor začíná definicí verze, za kterou následuje services uzel, pod kterým jsou definovány všechny služby. Sdílené sítě jsou obvykle definovány na konci tohoto souboru.

Chcete-li začít, zkopírujte tento standardní kód do souboru docker-compose.yml soubor:

docker-compose.yml

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Nyní upravíme services uzel zahrnout app , db a nginx služby.

app Služba

app služba nastaví kontejner s názvem travellist-app . Vytváří nový obrázek Dockeru na základě souboru Dockerfile umístěného ve stejné cestě jako docker-compose.yml soubor. Nový obrázek bude uložen lokálně pod názvem travellist .

I když je kořen dokumentu obsluhovaný jako aplikace umístěn v nginx kontejneru, potřebujeme soubory aplikace někde uvnitř app kontejner, takže jsme schopni provádět úlohy příkazového řádku pomocí nástroje Laravel Artisan.

Zkopírujte následující definici služby pod services uzel uvnitř docker-compose.yml soubor:

docker-compose.yml

  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

Tato nastavení provádějí následující:

• build :Tato konfigurace říká Docker Compose, aby vytvořil místní image pro app pomocí zadané cesty (kontextu) a souboru Dockerfile pro pokyny. Argumenty user a uid se vkládají do souboru Dockerfile, aby bylo možné přizpůsobit příkazy pro vytváření uživatelů v době sestavování.
• image :Název, který bude použit pro vytvářený obrázek.
• container_name :Nastaví název kontejneru pro tuto službu.
• restart :Vždy restartujte, pokud není služba zastavena.
• working_dir :Nastaví výchozí adresář pro tuto službu jako /var/www .
• volumes :Vytvoří sdílený svazek, který bude synchronizovat obsah z aktuálního adresáře do /var/www uvnitř nádoby. Všimněte si, že toto není kořenový adresář vašeho dokumentu, protože bude uložen v nginx kontejner.
• networks :Nastaví tuto službu tak, aby používala síť s názvem travellist .

db Služba

db služba používá předem vytvořený obraz MySQL 8.0 z Docker Hub. Protože Docker Compose automaticky načte .env proměnné soubory umístěné ve stejném adresáři jako docker-compose.yml můžeme získat nastavení naší databáze z Laravel .env soubor, který jsme vytvořili v předchozím kroku.

Zahrňte do svých services následující definici služby uzel hned za app služba:

docker-compose.yml

  db:
    image: mysql:8.0
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

Tato nastavení provádějí následující:

• image :Definuje obrázek Docker, který by měl být použit pro tento kontejner. V tomto případě používáme obraz MySQL 5.7 z Docker Hub.
• container_name :Nastaví název kontejneru pro tuto službu:travellist-db .
• restart :Vždy restartujte tuto službu, pokud není výslovně zastavena.
• environment :Definuje proměnné prostředí v novém kontejneru. Používáme hodnoty získané z Laravel .env soubor k nastavení naší služby MySQL, která automaticky vytvoří novou databázi a uživatele na základě poskytnutých proměnných prostředí.
• volumes :Vytvoří svazek pro sdílení .sql výpis databáze, který bude použit k inicializaci databáze aplikace. Obrázek MySQL bude automaticky importovat .sql soubory umístěné v /docker-entrypoint-initdb.d adresář uvnitř kontejneru.
• networks :Nastaví tuto službu tak, aby používala síť s názvem travellist .

nginx Služba

nginx služba používá předem vytvořený obraz Nginx nad Alpine, odlehčenou distribucí Linuxu. Vytvoří kontejner s názvem travellist-nginx a používá ports definice k vytvoření přesměrování z portu 8000 na hostitelském systému na port 80 uvnitř kontejneru.

Zahrňte do svých services následující definici služby uzel, hned za db služba:

docker-compose.yml

  nginx:
    image: nginx:1.17-alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d
    networks:
      - travellist

Tato nastavení provádějí následující:

• image :Definuje obrázek Docker, který by měl být použit pro tento kontejner. V tomto případě používáme obrázek Alpine Nginx 1.17.
• container_name :Nastaví název kontejneru pro tuto službu:travellist-nginx .
• restart :Vždy restartujte tuto službu, pokud není výslovně zastavena.
• ports :Nastaví přesměrování portu, které umožní externí přístup přes port 8000 na webový server běžící na portu 80 uvnitř kontejneru.
• volumes :Vytvoří dva sdílené svazky. První z nich bude synchronizovat obsah z aktuálního adresáře do /var/www uvnitř nádoby. Tímto způsobem, když provedete místní změny v souborech aplikace, budou se rychle projevovat v aplikaci, kterou Nginx obsluhuje uvnitř kontejneru. Druhý svazek zajistí náš konfigurační soubor Nginx, který se nachází na adrese docker-compose/nginx/travellist.conf , se zkopíruje do konfigurační složky Nginx kontejneru.
• networks :Nastaví tuto službu tak, aby používala síť s názvem travellist .

Dokončeno docker-compose.yml Soubor

Takto jsme dokončili docker-compose.yml soubor vypadá takto:

docker-compose.yml

version: "3.7"
services:
  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

  db:
    image: mysql:8.0
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

  nginx:
    image: nginx:alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d/
    networks:
      - travellist

networks:
  travellist:
    driver: bridge

Až budete hotovi, nezapomeňte soubor uložit.

Krok 6 – Spuštění aplikace pomocí Docker Compose

Nyní použijeme docker-compose příkazy k vytvoření obrazu aplikace a spuštění služeb, které jsme zadali v našem nastavení.

Vytvořte app obrázek pomocí následujícího příkazu:

docker-compose build app

Dokončení tohoto příkazu může trvat několik minut. Uvidíte výstup podobný tomuto:

OutputBuilding app
Sending build context to Docker daemon  377.3kB
Step 1/11 : FROM php:7.4-fpm
 ---> 8c08d993542f
Step 2/11 : ARG user
 ---> e3ce3af04d87
Step 3/11 : ARG uid
 ---> 30cb921ef7df
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     libxml2-dev     zip     unzip
. . .
 ---> b6dbc7a02e95
Step 5/11 : RUN apt-get clean && rm -rf /var/lib/apt/lists/*
 ---> 10ef9dde45ad
. . .
Step 6/11 : RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd
. . .
 ---> 920e4f09ec75
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> dbbcd44e44af
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> db98e899a69a
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> 5119e26ebfea
Step 10/11 : WORKDIR /var/www
 ---> 699c491611c0
Step 11/11 : USER $user
 ---> cf250fe8f1af
Successfully built cf250fe8f1af
Successfully tagged travellist:latest

Po dokončení sestavení můžete prostředí spustit v režimu na pozadí pomocí:

docker-compose up -d

OutputCreating travellist-db    ... done
Creating travellist-app   ... done
Creating travellist-nginx ... done

Tím budou vaše kontejnery spuštěny na pozadí. Chcete-li zobrazit informace o stavu vašich aktivních služeb, spusťte:

docker-compose ps

Uvidíte výstup takto:

Output      Name                    Command              State                  Ports                
-----------------------------------------------------------------------------------------------
travellist-app     docker-php-entrypoint php-fpm   Up      9000/tcp                            
travellist-db      docker-entrypoint.sh mysqld     Up      3306/tcp, 33060/tcp                 
travellist-nginx   nginx -g daemon off;            Up      0.0.0.0:8000->80/tcp,:::8000->80/tcp

Vaše prostředí je nyní v provozu, ale k dokončení nastavení aplikace musíme ještě provést několik příkazů. Můžete použít docker-compose exec příkaz pro provádění příkazů v kontejnerech služeb, jako je ls -l pro zobrazení podrobných informací o souborech v adresáři aplikace:

docker-compose exec app ls -l

Outputtotal 256
-rw-r--r-- 1 sammy sammy    737 Apr 18 14:21 Dockerfile
-rw-r--r-- 1 sammy sammy    101 Jan  7  2020 README.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 app
-rwxr-xr-x 1 sammy sammy   1686 Jan  7  2020 artisan
drwxr-xr-x 3 sammy sammy   4096 Jan  7  2020 bootstrap
-rw-r--r-- 1 sammy sammy   1501 Jan  7  2020 composer.json
-rw-r--r-- 1 sammy sammy 179071 Jan  7  2020 composer.lock
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 config
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 database
drwxr-xr-x 4 sammy sammy   4096 Apr 18 14:22 docker-compose
-rw-r--r-- 1 sammy sammy   1017 Apr 18 14:29 docker-compose.yml
-rw-r--r-- 1 sammy sammy   1013 Jan  7  2020 package.json
-rw-r--r-- 1 sammy sammy   1405 Jan  7  2020 phpunit.xml
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 public
-rw-r--r-- 1 sammy sammy    273 Jan  7  2020 readme.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 resources
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 routes
-rw-r--r-- 1 sammy sammy    563 Jan  7  2020 server.php
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 storage
drwxr-xr-x 4 sammy sammy   4096 Jan  7  2020 tests
-rw-r--r-- 1 sammy sammy    538 Jan  7  2020 webpack.mix.js

Nyní spustíme composer install k instalaci závislostí aplikace:

docker-compose exec app rm -rf vendor composer.lock
docker-compose exec app composer install

Uvidíte výstup takto:

OutputNo composer.lock file present. Updating dependencies to latest instead of installing from lock file. See https://getcomposer.org/install for more information.
. . .
Lock file operations: 89 installs, 0 updates, 0 removals
  - Locking doctrine/inflector (2.0.4)
  - Locking doctrine/instantiator (1.4.1)
  - Locking doctrine/lexer (1.2.3)
  - Locking dragonmantank/cron-expression (v2.3.1)
  - Locking egulias/email-validator (2.1.25)
  - Locking facade/flare-client-php (1.9.1)
  - Locking facade/ignition (1.18.1)
  - Locking facade/ignition-contracts (1.0.2)
  - Locking fideloper/proxy (4.4.1)
  - Locking filp/whoops (2.14.5)
. . .
Writing lock file
Installing dependencies from lock file (including require-dev)
Package operations: 89 installs, 0 updates, 0 removals
  - Downloading doctrine/inflector (2.0.4)
  - Downloading doctrine/lexer (1.2.3)
  - Downloading dragonmantank/cron-expression (v2.3.1)
  - Downloading symfony/polyfill-php80 (v1.25.0)
  - Downloading symfony/polyfill-php72 (v1.25.0)
  - Downloading symfony/polyfill-mbstring (v1.25.0)
  - Downloading symfony/var-dumper (v4.4.39)
  - Downloading symfony/deprecation-contracts (v2.5.1)
. . .
Generating optimized autoload files
> Illuminate\Foundation\ComposerScripts::postAutoloadDump
> @php artisan package:discover --ansi
Discovered Package: facade/ignition
Discovered Package: fideloper/proxy
Discovered Package: laravel/tinker
Discovered Package: nesbot/carbon
Discovered Package: nunomaduro/collision
Package manifest generated successfully.

Poslední věc, kterou musíme před testováním aplikace udělat, je vygenerovat jedinečný aplikační klíč pomocí artisan Nástroj příkazového řádku Laravel. Tento klíč se používá k šifrování uživatelských relací a dalších citlivých dat:

docker-compose exec app php artisan key:generate

OutputApplication key set successfully.

Nyní přejděte do prohlížeče a získejte přístup k názvu domény nebo IP adrese vašeho serveru na portu 8000:

http://server_domain_or_IP:8000

Poznámka :V případě, že toto demo spouštíte na svém místním počítači, použijte http://localhost:8000 pro přístup k aplikaci z vašeho prohlížeče.

Zobrazí se stránka podobná této:

Můžete použít logs příkaz ke kontrole protokolů generovaných vašimi službami:

docker-compose logs nginx

Attaching to travellist-nginx
. . .
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:49:16 +0000] "GET / HTTP/1.1" 200 627 "-" "curl/7.82.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET /favicon.ico HTTP/1.1" 200 0 "http://localhost:8000/" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"

Pokud chcete pozastavit prostředí Docker Compose a zároveň zachovat stav všech jeho služeb, spusťte:

docker-compose pause

OutputPausing travellist-db    ... done
Pausing travellist-nginx ... done
Pausing travellist-app   ... done

Poté můžete obnovit své služby pomocí:

docker-compose unpause

OutputUnpausing travellist-app   ... done
Unpausing travellist-nginx ... done
Unpausing travellist-db    ... done

Chcete-li prostředí Docker Compose vypnout a odebrat všechny jeho kontejnery, sítě a svazky, spusťte:

docker-compose down

OutputStopping travellist-nginx ... done
Stopping travellist-db    ... done
Stopping travellist-app   ... done
Removing travellist-nginx ... done
Removing travellist-db    ... done
Removing travellist-app   ... done
Removing network travellist-laravel-demo_travellist

Přehled všech příkazů Docker Compose naleznete v odkazu na příkazový řádek Docker Compose.

Závěr

V této příručce jsme nastavili prostředí Docker se třemi kontejnery pomocí Docker Compose k definování naší infrastruktury v souboru YAML.

Od tohoto okamžiku můžete pracovat na své aplikaci Laravel, aniž byste museli instalovat a nastavovat místní webový server pro vývoj a testování. Navíc budete pracovat s jednorázovým prostředím, které lze snadno replikovat a distribuovat, což může být užitečné při vývoji vaší aplikace a také při přechodu k produkčnímu prostředí.