Úvod
Průběžná integrace (CI) a průběžné nasazování (CD) patří v současnosti k nejpopulárnějším tématům ve vývoji softwaru. K dosažení CI/CD aspektu softwarové architektury vývojáři využívají kontejnery. Kontejnery jsou lehká, virtualizovaná, přenosná, softwarově definovaná prostředí. V kontejnerech může software běžet izolovaně od ostatního softwaru běžícího na fyzickém hostitelském stroji. Tento návod se zaměřuje na použití kontejnerové platformy Docker k nasazení a spuštění webových aplikací. Docker pomáhá zjednodušit proces nastavení zásobníku webového serveru. V tomto návodu použijeme zásobník LEMP k provozování Laravel aplikace.
Zásobník LEMP kombinuje Linux jako operační systém, Nginx jako webový server, MySQL jako databázi a PHP jako jazyk pro skriptování a dynamické zpracování. Můžete postupovat podle našeho návodu, jak nainstalovat a nakonfigurovat zásobník LEMP na Ubuntu. Laravel je jedním z nejlepších PHP frameworků pro vývoj webových aplikací.
Docker poskytuje nástroj s názvem Docker Compose pro definování procesu nastavení docker kontejneru. Docker Compose umožňuje vývojářům definovat infrastrukturu jejich aplikace, služby, svazky, sítě a jakékoli závislosti v jednom souboru nazvaném docker-compose. Může spravovat více Docker kontejnerů pomocí svých příkazů, jako jsou docker container create, docker container run atd.
V tomto návodu se naučíte, jak nasadit webovou aplikaci Laravel s Nginx a MySQL uvnitř Docker kontejneru. Konfigurace pro celý zásobník budou definovány uvnitř souboru docker-compose, stejně jako další konfigurační soubory pro PHP, MySQL a Nginx. Začněme!
Nejprve to nejdůležitější
- Jelikož se jedná o praktický návod, měli byste mít nainstalovaný Ubuntu 20.04 jako vaše výchozí operační prostředí. Měli byste také mít uživatele bez oprávnění root s právy sudo. Zde je podrobný návod, který vám pomůže nastavit váš server Ubuntu.
- . Musíte nainstalovat Docker. Máme návod na jak nainstalovat a provozovat Docker na Ubuntu 18.04.
- . Musíte nainstalovat Docker Compose podle návodu z oficiální dokumentace Dockeru.
Krok 1: Stažení Laravelu a instalace závislostí
Prvním krokem je získání kódu Laravelu z repozitáře. V reálných scénářích můžete mít svůj kód Laravelu v nějakém repozitáři, např. na GitHubu, Bitbucketu, GitLabu atd. Pro účely tohoto návodu však budeme klonovat nejnovější verzi z oficiálního repozitáře Laravelu na GitHub. Repozitář obsahuje soubor composer, což je správce závislostí na úrovni aplikace pro PHP. Protože chceme, aby vše běželo uvnitř Docker kontejneru, nainstalujeme závislosti pomocí Docker obrazu composer. To nám také pomůže vyhnout se nutnosti instalovat composer globálně na skutečném hostitelském stroji. Dále spusťte terminál.
Přejděte do svého domovského adresáře:
|
1 |
cd ~ |
Zadejte následující příkaz pro naklonování repozitáře do adresáře s názvem laravel-web. Můžete jej pojmenovat jakkoli chcete. V době psaní tohoto návodu tento příkaz stáhne Laravel verze 8. Až příkaz spustíte, pravděpodobně najdete novější verzi:
|
1 |
git clone https://github.com/laravel/laravel.git laravel-web |
Poté přejděte do adresáře, do kterého jste právě naklonovali repozitář:
|
1 |
cd ~/laravel-web |
Zadejte následující příkaz pro připojení adresářů potřebných pro vaši aplikaci Laravel pomocí Docker composer obrazu:
|
1 |
docker run --rm -v $(pwd):/app composer install |
Příznaky -v a –rm v příkazu docker run vytvoří dočasný kontejner, který bude před odstraněním připojen k aktuálnímu adresáři. Příkaz zkopíruje obsah ~/laravel-web do kontejneru a zajistí, že složka vendor vytvořená nástrojem composer bude zkopírována zpět do aktuálního adresáře.
Nyní musíte změnit vlastnictví adresáře laravel-web na uživatele, který není root. To vám umožní pracovat s kódem aplikace jako uživatel bez oprávnění root a v následujících krocích spouštět procesy uvnitř kontejneru. Pro změnu vlastnictví zadejte následující příkaz:
|
1 |
sudo chown -R $USER:$USER ~/laravel-web |
Kód vaší aplikace je nyní na svém místě. Adresář je vlastněn uživatelem bez oprávnění root, takže můžete pokračovat v definování aplikačních služeb v souboru docker-compose.
Krok 2: Vytvoření souboru Docker Compose
Docker Compose zjednodušuje proces sestavení a nasazení aplikace. Jakmile definujete konfigurace a služby, můžete aplikaci snadno nasadit na jakémkoli hostitelském stroji, který má nainstalovaný Docker a Docker Compose, aniž byste se museli starat o závislosti aplikace. Co je nejdůležitější, můžete to udělat pomocí jediného příkazu Docker Compose, jak uvidíme v Kroku 9.
V tomto kroku definujete soubor Docker Compose s konfiguracemi pro webový server, databázi a aplikační služby potřebné k nasazení aplikace Laravel.
Soubory Docker Compose jsou YAML soubory uložené s příponou .yml. Upozorňujeme, že pro platný soubor Docker Compose je nutné správné odsazení. Zadejte následující příkaz pro vytvoření a otevření souboru v editoru nano:
|
1 |
nano ~/laravel-web/docker-compose.yml |
Dále v tomto souboru definujete tři služby: app, webserver a db. Sekce db definuje přihlašovací údaje k databázi pro vaši aplikaci, takže se ujistěte, že jste zvolili silné mysql_root_password a v této sekci jej nahradili. Zkopírujte a vložte následující kód:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
version: '2.0' services: #PHP služba app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ networks: - app-network #Nginx služba webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" networks: - app-network #MySQL služba db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql networks: - app-network #Docker sítě networks: app-network: driver: bridge |
Níže naleznete vysvětlení definic služeb z výše uvedeného kódu:
- app: Definuje aplikaci Laravel a spouští vlastní Docker image, cloudsigma.com/php, který definujeme v Kroku 4. Také nastavuje working_dir v kontejneru na /var/www/html.
- webserver: Stáhne nginx:alpine image z Dockeru a vystaví porty 80 a 443.
- db: Stáhne image mysql:5.7.32 z Dockeru a definuje několik proměnných prostředí. Ty zahrnují databázi s názvem laravel_web pro aplikaci a root heslo pro databázi. Databázi můžete přejmenovat na název podle svého výběru. Nezapomeňte nahradit vlastnost MYSQL_ROOT_PASSWORD silným heslem. Tato služba také mapuje port 3306 na hostiteli na port 3306 v kontejneru.
Vlastnost container_name v každé službě definuje název kontejneru odpovídající dané službě. Pokud tuto vlastnost nedefinujete, Docker zvolí pro každý kontejner náhodný název.
Vlastnost networks definuje přemostěnou síť s názvem app-network, která usnadňuje komunikaci mezi kontejnery. Přemostěná síť je řízena softwarovým mostem, který umožňuje komunikaci pouze mezi kontejnery na stejném síťovém mostu. Softwarový řadič mostu instaluje ovladače, které zabraňují kontejnerům v různých přemostěných sítích v přímé vzájemné komunikaci. To zajišťuje vysokou úroveň zabezpečení, protože přímo spolu mohou komunikovat pouze související služby. Můžete se rozhodnout definovat více služeb a sítí připojujících se k souvisejícím funkcím.
Krok 3: Jak trvale uchovávat data
Vaše webová aplikace bude zpracovávat a poskytovat data vašim uživatelům. V tomto kroku vás provedeme definováním svazků (volumes) a připojení typu bind (bind mounts) pro definice vašich služeb, aby se data aplikace trvale uchovala. Docker nabízí neuvěřitelné funkce, jako jsou připojení typu bind a svazky pro trvalé uchovávání dat a ukládání konfiguračních souborů aplikace. Použijeme je při nastavení naší aplikace Laravel s Dockerem.
Svazky jsou upřednostňovány z různých důvodů, včetně nabízení záloh a uchovávání dat i po skončení životního cyklu kontejneru. Připojení typu bind obvykle odkazují na skutečný adresář na hostitelském stroji. Když vytvoříte svazek, vytvoří se nový adresář v úložném adresáři Dockeru, který je spravován Dockerem. Když vytvoříte připojení typu bind, soubor nebo adresář v hostitelském stroji se namontuje do kontejneru (odkazuje se na něj jeho absolutní cestou). To je pro naši webovou aplikaci zásadní, protože když provedete změny v kódu na hostitelském stroji, okamžitě se zpřístupní v kontejneru.
Při používání připojení typu bind buďte opatrní. Procesy běžící uvnitř kontejneru Docker mohou provádět změny v souborovém systému hostitele a ovlivnit procesy mimo Docker běžící na hostitelském systému. Přestože jsou připojení v Dockeru výkonnou funkcí, buďte si vědomi těchto bezpečnostních důsledků.
Po tomto úvodu se podívejme, jak můžeme tyto dvě funkce použít v našem nastavení. Nejprve definujeme svazek pro trvalé uchovávání databáze MySQL. V souboru Docker Compose, který jsme vytvořili, přidejte pod službu db vlastnost volumes, jak je zvýrazněno níže:
|
1 2 3 4 5 6 7 8 |
#Služba MySQL db: ... volumes: - dbdata:/var/lib/mysql/ networks: - app-network ... |
Jak je definováno, svazek dbdata bude trvale uchovávat obsah adresáře /var/lib/mysql. Usnadňuje zálohování a umožňuje restartování služeb bez ztráty dat. Dále byste měli přidat definici svazků na konec souboru Docker Compose, aby byla dostupná napříč službami. Na konec souboru vložte následující fragment kódu:
|
1 2 3 4 |
#Svazky volumes: dbdata: driver: local |
Chcete-li se připojit k databázi MySQL, musíte poskytnout přihlašovací údaje. Chcete-li tak učinit, definujte připojení typu bind přidáním následujícího zvýrazněného fragmentu kódu do služby db pod vlastnost volumes:
|
1 2 3 4 5 6 7 |
#Služba MySQL db: ... volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf ... |
Kód připojuje ~/laravel-web/mysql/my.cnf k /etc/mysql/my.cnf v kontejneru. Připojený soubor představuje konfigurační soubory MySQL, které vytvoříme v kroku 7..
Kontejner musí používat server Nginx k poskytování kódu vaší aplikace. Proto pro tento účel definujeme dvě připojení typu bind (jedno pro konfigurační soubor Nginx a jedno pro kód aplikace) pod službou webserver. Pod službu webserver přidejte následující fragment kódu pro definici svazků:
|
1 2 3 4 5 6 7 8 |
#Služba Nginx webserver: ... volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network |
Tento řádek – ./:/var/www/html propojuje kód aplikace v adresáři ~/laravel-web s adresářem /var/www/html uvnitř kontejneru. Pro druhé připojení typu bind mount bude vytvořen konfigurační soubor pro Nginx v ~/laravel-web/nginx/conf.d/. Bude připojen do /etc/nginx/conf.d/ uvnitř kontejneru. Díky tomu můžete konfigurační soubor na hostitelském stroji podle potřeby aktualizovat. Konfigurační soubor pro Nginx vytvoříme v Kroku 6.
Aby se změny v kódu automaticky projevily v kontejneru, připojíme kód aplikace do kontejneru pomocí bind mount. To urychlí proces nasazení. Přidejte proto do služby app následující zvýrazněný úryvek kódu:
|
1 2 3 4 5 6 7 8 |
#Služba PHP app: ... volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network |
Druhý řádek připojuje konfigurační soubor PHP, který vytvoříme v Kroku 5 uvnitř souboru ~/laravel-web/php/laravel.ini do /usr/local/etc/php/conf.d/laravel.ini uvnitř kontejneru.
Váš kompletní soubor Docker Compose by nyní měl vypadat takto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
version: '2.0' services: #Služba PHP app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network #Služba Nginx webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network #Služba MySQL db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf networks: - app-network #Sítě Dockeru networks: app-network: driver: bridge #Svazky volumes: dbdata: driver: local |
Pokud vše vypadá v pořádku, stiskněte Ctrl + O pro uložení souboru. Poté stiskněte Ctrl + X pro ukončení editoru. V tomto okamžiku byste měli být schopni sestavit vlastní Docker obraz pro vaši aplikaci pomocí souboru Docker Compose.
Krok 4: Vytvoření souboru Dockerfile
Dockerfile obsahuje instrukce, které Docker může použít k sestavení vlastních Docker obrazů. Může také nainstalovat požadovaný software a nakonfigurovat potřebná nastavení pro vaši aplikaci. Tyto instrukce definují prostředí uvnitř kontejneru, který bude hostovat kód vaší aplikace. Vytvořené obrazy můžete nahrát na Docker Hub za účelem sdílení nebo je umístit do jiných soukromých registrů.
Vytvoříme Dockerfile, který bude specifikovat instrukce pro sestavení obrazu aplikace Laravel. Pomocí editoru nano vytvořte Dockerfile v adresáři ~/laravel-web:
|
1 |
nano ~/laravel-web/Dockerfile |
V otevřeném editoru přidejte následující kód:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
FROM php:7.4-fpm # Zkopírujte composer.lock a composer.json do pracovního adresáře COPY composer.lock composer.json /var/www/html/ # Nastavte pracovní adresář WORKDIR /var/www/html/ # Nainstalujte závislosti pro operační systém RUN apt-get update && apt-get install -y \ build-essential \ libpng-dev \ libjpeg62-turbo-dev \ libfreetype6-dev \ locales \ zip \ jpegoptim optipng pngquant gifsicle \ vim \ libzip-dev \ unzip \ git \ libonig-dev \ curl # Vymažte mezipaměť RUN apt-get clean && rm -rf /var/lib/apt/lists/* # Nainstalujte rozšíření pro php RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl RUN docker-php-ext-configure gd --with-freetype --with-jpeg RUN docker-php-ext-install gd # Nainstalujte composer (správce balíčků php) RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer # Zkopírujte obsah stávajícího adresáře aplikace do pracovního adresáře COPY . /var/www/html # Přiřaďte oprávnění pracovního adresáře uživateli www-data RUN chown -R www-data:www-data \ /var/www/html/storage \ /var/www/html/bootstrap/cache # Zpřístupněte port 9000 a spusťte server php-fpm (pro FastCGI Process Manager) EXPOSE 9000 CMD ["php-fpm"] |
Dockerfile nejprve vytvoří obraz založený na php:7.4-fpm obrazu Dockeru. Jedná se o obraz založený na Debianu s nainstalovanou implementací PHP FastCGI (PHP-FPM ). Aby Laravel správně fungoval, vyžaduje další rozšíření PHP, jako jsou mcrypt, pdo_mysql, mbstring a imagick, která skript nainstaluje. Poté nainstaluje composer správce balíčků PHP. Kontejner jej použije k instalaci závislostí PHP pro Laravel.
Pomocí direktivy RUN můžete definovat příkazy, jako je instalace, aktualizace a konfigurace nastavení uvnitř kontejneru. Také přiřazuje uživatelská oprávnění. Direktiva WORKDIR specifikuje pracovní adresář, v tomto případě /var/www/html. Skript spustí příkaz CHOWN pro přiřazení oprávnění k adresáři /var/www/html uživateli www-data.
Před samotným sestavením obrazu je nutné zpřístupnit port, který umožní přístup k aplikaci běžící uvnitř kontejneru. Příkaz EXPOSE zpřístupní port 9000 pro server php-fpm. Posledním spuštěným příkazem je direktiva CMD. Ta spustí php-fpm pro spuštění serveru.
Nyní můžete stisknout Ctrl + O pro uložení souboru. Poté stiskněte Ctrl + X pro ukončení editoru.
Krok 5: Konfigurace PHP
V tomto kroku nakonfigurujeme službu php tak, aby zpracovávala příchozí požadavky z Nginx. Vytvoříte soubor laravel.ini uvnitř adresáře php. Tento soubor bude obsahovat konfigurace PHP. Toto je soubor, který jste připojili pomocí bind-mount do /usr/local/etc/php/conf.d/laravel.ini v kontejneru v Kroku 3. Konfigurace v tomto souboru přepisují výchozí soubor php.ini, který PHP obvykle načítá při svém spuštění. Zadejte následující příkaz pro vytvoření adresáře php:
|
1 |
mkdir ~/laravel-web/php |
Vytvořte a otevřete soubor laravel.ini uvnitř adresáře php zadáním následujícího příkazu:
|
1 |
nano ~/laravel-web/php/laravel.ini |
Výchozí php.ini soubor má limit pro nahrávání nastavený na 2M. Jako příklad si ukážeme, jak upravit a nastavit konfigurace php změnou hodnoty povoleného limitu pro nahrávání, pro případ, že byste chtěli nahrávat větší soubory. Zadejte do souboru následující řádky kódu:
|
1 2 |
upload_max_filesize=80M post_max_size=80M |
Tím se nastaví limit pro nahrávání a můžete nahrávat soubory o celkové velikosti maximálně 80 MB. Do souboru laravel.ini můžete přidat další konfigurace php, které přepíší výchozí konfigurace php. Nyní soubor uložte a zavřete.
Krok 6: Konfigurace Nginx
V tomto kroku nakonfigurujeme Nginx tak, aby používal službu php, kterou jsme definovali dříve. Bude používat PHP-FPM jako FastCGI server pro obsluhu dynamického obsahu. FastCGI server je software, který umožňuje interaktivním programům komunikovat s webovým serverem.
Jak jsme definovali v souboru docker-compose v Kroku 3, vytvoříme konfigurační soubor Nginx app.conf uvnitř adresáře ~/laravel-web/nginx/conf.d/. Nejprve zadejte následující příkaz pro vytvoření adresáře:
|
1 |
mkdir -p ~/laravel-web/nginx/conf.d |
Dále vytvořte a otevřete soubor app.conf pomocí nano zadáním následujícího příkazu:
|
1 |
nano ~/laravel-web/nginx/conf.d/app.conf |
Přidejte do souboru následující konfigurační kód Nginx:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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/html/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; } } |
Nginx čte konfigurační soubory zvané serverové bloky (server blocks), aby věděl, který adresář má být zobrazen návštěvníkovi webu na základě URL. Chcete-li se dozvědět více, přečtěte si o nastavení serverových bloků v našem návodu na instalaci Nginx na Ubuntu 18.04. Definované direktivy slouží k následujícím účelům:
- listen – Definuje port, na kterém bude server naslouchat příchozím požadavkům, což je obvykle port 80.
- error_log & access_log – Definuje soubory pro zápis aplikačních logů.
- root – Definuje cestu k webrootu, což je adresář, který bude obsluhovat jakýkoli požadavek odeslaný na server z internetu.
V bloku location pro php určuje direktiva fastcgi_pass, že služba app naslouchá na TCP socketu na portu 9000 (který byl definován v Dockerfile). To nasměruje server PHP-FPM, aby naslouchal přes síť a ne na Unix socketu. I když Unix socket může mít mírnou výhodu v rychlosti oproti TCP socketu, postrádá síťový protokol, čímž obchází síťový zásobník.
Unixový socket by byl vhodnější pro scénáře, kdy jsou hostitelé umístěni na jednom stroji. Pokud však máte služby běžící na různých hostitelích, TCP socket má výhodu v propojení distribuovaných služeb. V našem případě běží kontejner aplikace na jiném hostiteli než kontejner našeho webového serveru. Pro naši konfiguraci je tedy nejvhodnější TCP socket.
Nyní můžete stisknout Ctrl + O pro uložení souboru a poté Ctrl + X pro ukončení editoru. Změny provedené v adresáři nginx/conf.d/ se automaticky projeví v kontejneru webového serveru díky připojení typu bind mount, které jste přidali do souboru Docker Compose v Kroku 3.
Krok 7: Konfigurace MySQL
Poté, co jsme nakonfigurovali Nginx pro práci s PHP, můžeme nyní nakonfigurovat MySQL pro ukládání a poskytování dynamických dat pro PHP. Již dříve jsme v souboru Docker Compose nastavili instalaci potřebných rozšíření pro komunikaci mezi PHP a MySQL. Konfigurační soubor MySQL my.cnf vytvoříme uvnitř složky mysql, která bude připojena pomocí bind mount do /etc/mysql/my.cnf, jak jsme definovali v sekci služby db v Docker Compose v Kroku 3.
Nastavení konfigurace MySQL a změny v souboru my.cnf můžete provádět, kdykoli chcete. Měly by se v kontejneru projevit okamžitě. Nejprve vytvořte adresář zadáním následujícího příkazu:
|
1 |
mkdir ~/laravel-web/mysql |
Dále vytvořte a otevřete nano zadáním následujícího příkazu:
|
1 |
nano ~/laravel-web/mysql/my.cnf |
Zadejte následující fragment kódu pro povolení protokolu dotazů a určení umístění souboru protokolu dotazů:
|
1 2 3 |
[mysqld] general_log = 1 general_log_file = /var/lib/mysql/general.log |
Definováním vlastnosti general_log na hodnotu 1 povolíte obecné protokoly. Vlastnost general_log_file určuje umístění souboru protokolů. Stisknutím Ctrl + O soubor uložte a stisknutím Ctrl + X ukončete editor.
Krok 8: Nastavení proměnných prostředí Laravelu
Do tohoto okamžiku jsou všechny služby a nastavení konfigurace dokončeny. Mohli bychom tedy nasadit naše kontejnery. Předtím, než bude naše webová aplikace skutečně použitelná, je však nutné provést jeden důležitý krok – nastavit proměnné prostředí. Rámec Laravel očekává soubor s názvem .env, který používá k definování svého prostředí. Ve výchozím nastavení je Laravel dodáván se souborem .env.example, který můžete zkopírovat do .env a poté upravit proměnné podle vašich skutečných údajů. Pro zkopírování souboru zadejte následující příkaz:
|
1 |
cp .env.example .env |
Po zkopírování otevřete soubor pomocí nano pro úpravy:
|
1 |
nano .env |
Zde je snímek obrazovky, jak může soubor vypadat:

V souboru je dalším krokem úprava proměnných v bloku DB_CONNECTION, jak jste je nastavili v předchozích konfiguracích, které jsme dosud provedli. Aktualizujte je následovně:
- DB_HOST je db databázový kontejner.
- DB_DATABASE je laravel_web.
- DB_USERNAME je uživatelské jméno pro databázi. Vyberte si jméno podle svého uvážení, ale pro účely tohoto návodu použijme laraveldocker.
- DB_PASSWORD je silné heslo, které výše uvedený uživatel použije k přihlášení do databáze, proto zvolte silné heslo. V Kroku 10, vytvoříme tohoto uživatele s heslem, které zde zvolíte.
Po aktualizaci hodnot by vaše DB_CONNECTION mělo vypadat takto:

Uložte a zavřete soubor.
Krok 9: Spuštění Docker kontejnerů
V této fázi jsou všechny vaše služby a konfigurace definovány v souboru Docker Compose. Ke spuštění všech kontejnerů, vytvoření svazků, připojení sítí a nastavení a sestavení vaší aplikace stačí jediný příkaz. Do terminálu zadejte následující příkaz:
|
1 |
docker-compose up -d |
Při prvním spuštění příkazu docker-compose up se stáhnou všechny potřebné Docker obrazy. Pokud nastavujete infrastrukturu na svém lokálním počítači, může to chvíli trvat. Jakmile jsou obrazy staženy, Compose vytvoří kontejnery. Příznak -d dává Dockeru pokyn ke spuštění kontejnerů na pozadí. Pokud proces proběhne úspěšně, měli byste v terminálu vidět něco takového:

Zadejte do terminálu následující příkaz pro výpis všech běžících kontejnerů:
|
1 |
docker ps |
Mělo by se zobrazit něco jako na snímku obrazovky níže, s podrobnostmi o kontejnerech app, webserver a db:

- CONTAINER ID – Jedinečný identifikátor pro každý kontejner.
- NAMES – Název služby přidružený ke každému kontejneru, jak je definován v souboru Docker Compose. (K přístupu ke kontejneru můžete použít buď ID kontejneru, nebo jeho název).
- IMAGE – Název obrazu pro každý kontejner.
- STATUS – Zobrazuje informace o stavu kontejneru (může být zastavený, běžící nebo se restartovat).
- PORTS – Ukazuje porty, které kontejner vystavuje.
Docker Compose poskytuje příkaz nazvaný exec, který můžete použít ke spuštění příkazů terminálu nebo k přístupu k příkazové řádce uvnitř kontejneru. Nejprve chceme spustit několik příkazů uvnitř kontejneru app, což je kontejner, v němž běží aplikace Laravel.
Docker poskytuje příkaz pro přístup k příkazové řádce kontejneru. Jeho syntaxe je následující: docker-compose exec container_name bash. Pro přístup k příkazové řádce kontejneru app zadejte následující příkaz:
|
1 |
docker-compose exec app bash |
Jakmile budete v příkazové řádce kontejneru, můžete spustit některé konfigurační příkazy Laravel Artisan. Zadejte následující příkaz pro vygenerování klíče laravel a jeho uložení do souboru .env:
|
1 |
php artisan key:generate |
S nastaveným klíčem prostředí můžete spustit následující příkaz pro uložení nastavení konfigurace do mezipaměti:
|
1 |
php artisan config:cache |
Konfigurace jsou uloženy v souboru /var/www/html/bootstrap/cache/config.php uvnitř kontejneru. Pro ukončení terminálu kontejneru můžete stisknout Ctrl + D.
Chcete-li potvrdit, že aplikace Laravel byla nasazena a běží, navštivte ve svém prohlížeči veřejnou IP adresu svého serveru (http://your_server_public_ip). Měli byste vidět uvítací stránku nové instalace Laravelu:

Step 10: Configure a MySQL user
V tomto kroku vytvoříme databázového uživatele pro databázi MySQL laravel_web, kterou jsme specifikovali v souboru docker-compose. Když jste spustili příkaz pro sestavení kontejneru v kroku 9, MySQL se nainstaloval, ale vytvořil pouze výchozí administrátorský účet root, který má neomezená oprávnění k databázi. Abyste se vyhnuli použití uživatele root, vytvoříme vyhrazeného uživatele laraveldocker, kterého budeme pro aplikaci používat. Toto je uživatel, kterého jste specifikovali v proměnných prostředí v kroku 8. Přístup k příkazové řádce uvnitř terminálu získáte zadáním následujícího příkazu:
|
1 |
docker-compose exec db bash |
Jakmile budete uvnitř kontejneru, přihlaste se do MySQL zadáním následujícího příkazu:
|
1 |
mysql -u root -p |
Na výzvu k zadání hesla zadejte heslo, které jste nastavili ve službě db v souboru docker-compose v kroku 2.
Jakmile se přihlásíte do příkazového řádku MySQL, zkontrolujte, zda vidíte databázi, kterou jste specifikovali v souboru docker-compose, zadáním následujícího SQL příkazu:
|
1 |
show databases; |
Měli byste vidět databázi laravel_web nebo jakýkoli jiný název, který jste pro své nastavení specifikovali:

Dále vytvoříme uživatele a heslo pro databázi laravel_web. Musí se jednat o stejné údaje, které jste specifikovali v souboru .env v kroku 8. Zadejte následující příkaz pro vytvoření uživatele a hesla a udělení všech oprávnění tomuto uživateli:
|
1 |
GRANT ALL ON laravel_web.* TO 'laraveldocker'@'%' IDENTIFIED BY 'your_strong_laravel_docker_password'; |
Aby se změny projevily okamžitě, zadejte následující příkaz pro vyčištění oprávnění:
|
1 |
FLUSH PRIVILEGES; |
Tím je konfigurace uživatele MySQL dokončena. Ukončete příkazový řádek MySQL zadáním exit a stisknutím klávesy Enter. Nakonec ukončete kontejner db stisknutím Ctrl + D.
Krok 11: Otestování komunikace mezi kódem aplikace Laravel a databází MySQL
Až do tohoto kroku vše fungovalo dobře. Chceme se však ujistit, že kód Laravelu v kontejneru app dokáže komunikovat s databází MySQL v kontejneru db. Nejprve přejděte do terminálu kontejneru app zadáním následujícího příkazu:
|
1 |
docker-compose exec app bash |
Dále je třeba spustit příkaz laravel migration, který vytvoří tabulky:
|
1 |
php artisan migrate |
V terminálu byste měli vidět průběh migrace, jak Laravel vytváří výchozí tabulky:

Dále otestujeme, zda máme k databázi přístup z Laravelu. Laravel standardně obsahuje nástroj Tinker, který vám umožňuje komunikovat s celou aplikací z příkazové řádky, včetně přístupu k databázi, spouštění úloh, eloquent ORM a dalších funkcí. Pomocí nástroje Tinker můžeme zobrazit data v tabulce migrací. Pro přístup k nástroji Tinker zadejte následující příkaz:
|
1 |
php artisan tinker |
Jakmile budete v příkazovém řádku Tinker, můžete vypsat tabulky vytvořené příkazem migrate zadáním následujícího:
|
1 |
\DB::select('show tables'); |
Níže uvedený snímek obrazovky ukazuje výstup, což jsou tabulky, které se aktuálně nacházejí v databázi laravel_web:

Data v tabulce můžete získat zadáním názvu tabulky. Data v tabulce migrations můžete například získat zadáním následujícího příkazu:
|
1 |
\DB::table('migrations')->get(); |
Příkaz vypíše následující:

Z výše uvedeného výstupu je patrné, že vaše aplikace Laravel je správně nakonfigurována a dokáže komunikovat s databází. Můžete experimentovat s dalšími příkazy, jako je vytváření modelů, spouštění úloh a další. Příkazový řádek Tinker můžete ukončit stisknutím Ctrl + D.
Závěr
V tomto návodu jste nasadili aplikaci Laravel s LEMP stackem uvnitř kontejneru Docker. Aplikaci jste otestovali přístupem k webovému rozhraní a také připojením k databázi prostřednictvím nástroje Laravel Tinker. Mohli jste si vyzkoušet sílu nástroje Docker Compose. Ten vám umožňuje vytvořit skupinu kontejnerů Docker definovaných v jednom souboru, které pak lze spustit jediným příkazem.
Pokud se chcete s kontejnery seznámit podrobněji, podívejte se na náš návod, který ukazuje, jak vyčistit prostředky Dockeru – obrazy, kontejnery a svazky a na náš podrobný přehled nástroje Kubernetes.
Můžete také navštívit náš blog, kde se dozvíte více o Dockeru a Continuous Integration a Continuous Deployment.
Ať se daří!
Komentáře
Zatím žádné komentáře. Buďte první.