Ինչպես տեղադրել Laravel-ը Docker-ով Ubuntu 22.04-ում

Այս ձեռնարկը գոյություն ունի ՕՀ-ի այս տարբերակների համար

Ubuntu 22.04 (Jammy Jellyfish)
Ubuntu 18.04 (Bionic Beaver)

Այս էջում

Նախադրյալներ
Քայլ 1 - Կարգավորել Firewall-ը
Քայլ 2 - Տեղադրեք SSL-ը
Քայլ 3 - Տեղադրեք Docker-ը և Docker Compose-ը
Քայլ 4 - Ներբեռնեք Laravel և տեղադրեք կախվածությունները
Քայլ 5 - Ստեղծեք Docker Compose ֆայլը
Քայլ 6 - Ստեղծեք Dockerfile-ը
Քայլ 7 - Կարգավորեք PHP-ն
Քայլ 8 - Կարգավորեք Nginx-ը
Քայլ 9 - Կարգավորեք MySQL-ը
Քայլ 10 - Շրջակա միջավայրի ֆայլի կարգավորում
Քայլ 11 - Սկսեք կոնտեյներները և ավարտեք Laravel-ի տեղադրումը
Քայլ 12 - Կարգավորեք SSL-ի նորացումը
Քայլ 13 - Տվյալների միգրացիա և Tinker Console
Եզրակացություն

Laravel-ը անվճար և բաց կոդով PHP շրջանակ է, որն ապահովում է գործիքների և ռեսուրսների մի շարք ժամանակակից PHP հավելվածներ ստեղծելու համար: Համատեղելի փաթեթների և ընդլայնումների լայն տեսականիով Laravel-ը դարձել է հանրաճանաչ, և շատ ծրագրավորողներ այն ընդունել են որպես իրենց ընտրության շրջանակ: Laravel-ը տրամադրում է տվյալների բազայի հզոր գործիքներ, ներառյալ ORM (Object Relational Mapper), որը կոչվում է Eloquent և ներկառուցված մեխանիզմներ տվյալների բազայի միգրացիաներ ստեղծելու համար: Այն մատակարարվում է Artisan հրամանի տողի գործիքով, որի միջոցով մշակողները կարող են բեռնել նոր մոդելներ, կարգավորիչներ և հավելվածի այլ բաղադրիչներ, ինչը արագացնում է հավելվածի ընդհանուր զարգացումը:

Հավելվածը կոնտեյներացնելը վերաբերում է հավելվածի և դրա բաղադրիչների հարմարեցման գործընթացին, որպեսզի այն կարողանան գործարկել թեթև միջավայրում, որը հայտնի է որպես կոնտեյներ: Այս ուղեցույցը կօգտագործի Docker Compose-ը Laravel հավելվածը մշակելու համար կոնտեյներականացնելու համար:

Մենք կստեղծենք երեք Docker կոնտեյներ մեր Laravel հավելվածի համար:

app ծառայություն, որն աշխատում է PHP 8.2-FPM
MySQL 8.0-ով աշխատող db ծառայություն
nginx ծառայություն, որն օգտագործում է app ծառայությունը PHP կոդը վերլուծելու համար, նախքան Laravel հավելվածը օգտատիրոջը մատուցելը:

Մենք նաև կստեղծենք SSL վկայագիր մեր Laravel կայքի համար՝ օգտագործելով Let's Encrypt:

Նախադրյալներ

Ubuntu 22.04-ով աշխատող սերվեր:

Ոչ արմատային օգտատեր՝ sudo արտոնություններով:

Լիովին որակավորված տիրույթի անուն (FQDN), որը ցույց է տալիս ձեր սերվերը: Մեր նպատակների համար մենք կօգտագործենք example.com որպես տիրույթի անուն:

Համոզվեք, որ ամեն ինչ թարմացվում է:

$ sudo apt update

Տեղադրեք հիմնական կոմունալ փաթեթներ: Դրանցից մի քանիսը կարող են արդեն տեղադրված լինել:

$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Քայլ 1 - Կարգավորել Firewall-ը

Առաջին քայլը firewall-ի կազմաձևումն է: Ubuntu-ն լռելյայն գալիս է ufw-ով (Uncomplicated Firewall):

Ստուգեք, արդյոք firewall-ը աշխատում է:

$ sudo ufw status

Դուք պետք է ստանաք հետևյալ արդյունքը.

Status: inactive

Թույլատրել SSH միացքը, որպեսզի այն միացնելուց հետո firewall-ը չխախտի ընթացիկ կապը:

$ sudo ufw allow OpenSSH

Թույլատրել նաև HTTP և HTTPS պորտերը:

$ sudo ufw allow http
$ sudo ufw allow https

Միացնել Firewall-ը

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Կրկին ստուգեք firewall-ի կարգավիճակը:

$ sudo ufw status

Դուք պետք է տեսնեք նմանատիպ արդյունք:

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Քայլ 2 - Տեղադրեք SSL-ը

Նախքան առաջ անցնելը, եկեք նախ ստեղծենք SSL վկայագիր մեր տիրույթի համար: Մենք դա կստեղծենք Docker-ից դուրս, քանի որ այն հեշտ է պահպանել: Մենք ավելի ուշ կհամաժամացնենք վկայականները կոնտեյների հետ, որը պարբերաբար կթարմացվի և թարմացվի:

SSL վկայագիր ստեղծելու համար մենք պետք է տեղադրենք Certbot-ը: Կարող եք կա՛մ տեղադրել Certbot-ը՝ օգտագործելով Ubuntu-ի պահոցը, կա՛մ ձեռք բերել վերջին տարբերակը՝ օգտագործելով Snapd գործիքը: Մենք կօգտագործենք Snapd տարբերակը:

Ubuntu 22.04-ը գալիս է լռելյայն տեղադրված Snapd-ով: Գործարկեք հետևյալ հրամանները՝ համոզվելու համար, որ Snapd-ի ձեր տարբերակը արդիական է: Համոզվեք, որ Snapd-ի ձեր տարբերակը արդիական է:

$ sudo snap install core
$ sudo snap refresh core

Տեղադրեք Certbot-ը:

$ sudo snap install --classic certbot

Օգտագործեք հետևյալ հրամանը՝ համոզվելու համար, որ Certbot հրամանն աշխատում է՝ ստեղծելով խորհրդանշական հղում դեպի /usr/bin գրացուցակը:

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Գործարկեք հետևյալ հրամանը՝ SSL վկայական ստեղծելու համար:

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d example.com

Վերոնշյալ հրամանը վկայական կներբեռնի ձեր սերվերի /etc/letsencrypt/live/example.com գրացուցակում:

Ստեղծեք Diffie-Hellman խումբ վկայագիր:

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Կատարեք գործընթացի չոր գործարկում՝ ստուգելու, թե արդյոք SSL-ի նորացումը լավ է աշխատում:

$ sudo certbot renew --dry-run

Եթե սխալներ չեք տեսնում, ամեն ինչ պատրաստ է: Ձեր վկայականը ինքնաբերաբար կերկարաձգվի:

Docker-ը կարգավորելուց և Laravel-ը տեղադրելուց հետո նորացման գործընթացը պետք է փոփոխվի: Մենք այն կանդրադառնանք հետագա բաժնում:

Քայլ 3 - Տեղադրեք Docker-ը և Docker Compose-ը

Ubuntu 22.04-ը մատակարարվում է Docker-ի ավելի հին տարբերակով: Վերջին տարբերակը տեղադրելու համար նախ ներմուծեք Docker GPG ստեղնը:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Ստեղծեք Docker պահեստային ֆայլ:

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Թարմացրեք համակարգի պահեստների ցանկը:

$ sudo apt update

Տեղադրեք Docker-ի վերջին տարբերակը:

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Ստուգեք, որ այն աշխատում է:

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2023-01-14 10:41:35 UTC; 2min 1s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 2054 (dockerd)
      Tasks: 52
     Memory: 22.5M
        CPU: 248ms
     CGroup: /system.slice/docker.service
             ??  2054 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Լռելյայնորեն, Docker-ը պահանջում է արմատային արտոնություններ: Եթե ցանկանում եք խուսափել sudo օգտագործումից ամեն անգամ, երբ գործարկում եք docker հրամանը, ավելացրեք ձեր օգտվողի անունը docker խմբին:

$ sudo usermod -aG docker $(whoami)

Դուք պետք է դուրս գաք սերվերից և նորից մուտք գործեք որպես նույն օգտվող՝ այս փոփոխությունը միացնելու համար կամ օգտագործեք հետևյալ հրամանը։

$ su - ${USER}

Հաստատեք, որ ձեր օգտվողն ավելացված է Docker խմբին:

$ groups
navjot wheel docker

Քայլ 4 - Ներբեռնեք Laravel և տեղադրեք կախվածությունները

Առաջին քայլն է ներբեռնել Laravel-ի վերջին տարբերակը և տեղադրել կախվածությունները, ներառյալ Composer-ը՝ PHP փաթեթի կառավարիչը:

Ստեղծեք Laravel հավելվածի գրացուցակը:

$ mkdir ~/laravel

Անցեք գրացուցակին:

$ cd ~/laravel

Կլոնավորեք Laravel-ի վերջին թողարկումը գրացուցակում: Մի մոռացեք հրամանի վերջում գտնվող :, ինչը նշանակում է, որ Git-ը կկլոնավորի ֆայլերը ընթացիկ գրացուցակում:

$ git clone https://github.com/laravel/laravel.git .

Օգտագործեք Docker's Compose պատկերը՝ ձեր Laravel նախագծի համար անհրաժեշտ դիրեկտորիաները տեղադրելու համար: Սա խուսափում է Composer-ի գլոբալ տեղադրման անհրաժեշտությունից:

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

Վերոնշյալ հրամանը ստեղծում է ժամանակավոր կոնտեյներ, որը կցվում է ձեր ընթացիկ գրացուցակին՝ նախքան հեռացնելը: Այն պատճենում է ձեր Laravel գրացուցակի բովանդակությունը կոնտեյների մեջ և երաշխավորում, որ vendor թղթապանակը, որը ստեղծում է Composer-ը կոնտեյների ներսում, հետ պատճենվում է ընթացիկ գրացուցակում:

Սահմանեք թույլտվությունները Laravel գրացուցակի վրա, որպեսզի այն պատկանի ներկայումս մուտք գործած օգտվողին:

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

Քայլ 5 - Ստեղծեք Docker Compose ֆայլը

Ստեղծեք և բացեք Docker compose ֆայլը խմբագրման համար:

$ nano docker-compose.yml

Դրա մեջ տեղադրեք հետևյալ կոդը. Այստեղ մենք սահմանում ենք երեք ծառայություններ՝ app, webserver և db: Փոխարինեք MYSQL_ROOT_PASSWORD db ծառայության տակ ձեր ընտրած ուժեղ գաղտնաբառով:

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: howtoforge/app
    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

  webserver:
    container_name: webserver
    image: nginx:alpine
    restart: unless-stopped
    tty: true
    ports:
        - 80:80
        - 443:443
    volumes:
        - ./:/var/www
        - ./nginx/conf.d:/etc/nginx/conf.d
        - ./nginx/logs:/var/log/nginx
        - /etc/ssl/certs/dhparam.pem:/etc/ssl/certs/dhparam.pem
        - /etc/letsencrypt:/etc/letsencrypt
    logging:
        options:
            max-size: "10m"
            max-file: "3"
    networks:
      - app-network

  db:
    image: mysql:latest
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
      MYSQL_USER: laraveluser
      MYSQL_PASSWORD: password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - dbdata:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - app-network

volumes:
  dbdata:
    driver: local

networks:
  app-network:
    driver: bridge

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է:

Եկեք մանրամասն քննարկենք ծառայությունները:

app - Այս ծառայությունը սահմանում է Laravel հավելվածը և գործարկում է հաճախորդի Docker պատկերը howtoforge/app վերնագրով: Մենք կստեղծենք այս պատկերը հաջորդ քայլում: Laravel-ի աշխատանքային գրացուցակը կոնտեյների ներսում դրված է /var/www հասցեով, որը քարտեզագրված է հոսթի ընթացիկ գրացուցակում: Մենք նաև տեղադրում ենք PHP կազմաձևման ֆայլ, որը պատճենվում է PHP կոնտեյներով: Մենք սա կկարգավորենք հետագա քայլում:
վեբսերվեր - Այս ծառայությունը ստեղծում է կոնտեյներ՝ օգտագործելով Nginx Docker պատկերը և ցուցադրում է 80 և 443 նավահանգիստները: Մենք նաև կապում ենք Nginx տեղեկամատյանների, հատուկ կազմաձևման, Laravel հավելվածի գրացուցակի և SSL վկայագրերի համար:
db - Այս ծառայությունը ստեղծում է կոնտեյներ՝ օգտագործելով MySQL Docker պատկերը և սահմանում է շրջակա միջավայրի փոփոխականներ՝ սահմանելով տվյալների բազայի անունը և MySQL արմատային գաղտնաբառը: Դուք կարող եք տվյալների բազան անվանել այն, ինչ ցանկանում եք, և MYSQL_ROOT_PASSWORD-ը փոխարինել ձեր ընտրած ուժեղ գաղտնաբառով: Նաև սահմանեք MySQL օգտվողի անունը (MYSQL_USER_NAME) և գաղտնաբառը (MYSQL_USER_PASSWORD), որոնք հասանելի կլինեն ձեր ընտրած տվյալների բազան: Այս ծառայությունը նաև քարտեզագրում է 3306 նավահանգիստը կոնտեյներից մինչև հյուրընկալողի 3306 նավահանգիստ: Մենք նաև կապում ենք ծավալը MySQL-ի հատուկ կազմաձևման համար և տեղական ծավալը MySQL տվյալների համար: Սա թույլ է տալիս վերագործարկել db ծառայությունը` առանց տվյալների կորստի:

Ծառայությունները միմյանց հետ հաղորդակցվելու համար մենք ստեղծել ենք Docker ցանց, որը կոչվում է app-network: Սահմանված է որպես կամրջային ցանց։ Այն թույլ է տալիս իր հետ կապված բեռնարկղերին հաղորդակցվել միմյանց հետ: Կամուրջի ցանցի վարորդը կանոններ է տեղադրում հյուրընկալող մեքենայում, որպեսզի տարբեր կամուրջ ցանցերի բեռնարկղերը չկարողանան ուղղակիորեն հաղորդակցվել միմյանց հետ:

Քայլ 6 - Ստեղծեք Dockerfile-ը

Dockerfile-ն օգտագործվում է հատուկ պատկերներ ստեղծելու համար: Laravel-ի համար ստանդարտ պատկեր չկա, այդ իսկ պատճառով մենք պետք է սահմանենք Dockerfile՝ Laravel-ի համար հատուկ պատկեր ստեղծելու համար: Այն պարունակում է հրամաններ՝ փաթեթներ տեղադրելու և Linux միջավայրը կարգավորելու համար՝ կախված ձեր հավելվածի կարիքներից: Դուք կարող եք նաև հրապարակել ձեր անհատական պատկերը Docker Hub-ում կամ որևէ մասնավոր Docker ռեգիստրում: Դուք կարող եք ավելին իմանալ մեր Dockerfile ձեռնարկ:

Ստեղծեք և բացեք Dockerfile-ը խմբագրման համար:

$ nano Dockerfile

Դրա մեջ տեղադրեք հետևյալ կոդը.

FROM php:8.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 \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    vim \
    libzip-dev \
    unzip \
    git \
    curl \
    libonig-dev

# 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 --enable-gd --with-freetype --with-jpeg
RUN docker-php-ext-install gd

# Install composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Copy existing application directory contents to the working directory
COPY . /var/www

# Assign permissions of the working directory to the www-data user
RUN chown -R www-data:www-data \
        /var/www/storage \
        /var/www/bootstrap/cache

# Assign writing permissions to logs and framework directories
RUN chmod 775 storage/logs \
        /var/www/storage/framework/sessions \
        /var/www/storage/framework/views

# Expose port 9000 and start php-fpm server
EXPOSE 9000
CMD ["php-fpm"]

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է:

Եկեք տեսնենք, թե ինչ է կատարվում այստեղ: Նախ, մենք ստեղծում ենք մեր հատուկ պատկերը php:8.2-fpm Docker պատկերի վերևում: Սա Debian-ի վրա հիմնված պատկեր է, որի վրա տեղադրված է PHP 8.2-FPM: Dockerfile-ն օգտագործում է տարբեր հրահանգներ՝ գործողություններ կատարելու համար, RUN հրահանգը սահմանում է հրամանները թարմացնելու, տեղադրելու և կարգավորելու կարգավորումները կոնտեյների ներսում, COPY հրահանգը ֆայլերը կոնտեյների մեջ պատճենելու համար, EXPOSE հրահանգ՝ կոնտեյների մեջ պորտը բացահայտելու համար, և CMD հրահանգ՝ հրաման գործարկելու համար:

Նախ, մենք պատճենում ենք Composer ֆայլերը Laravel գրացուցակից, որը գտնվում է կոնտեյների ներսում գտնվող հոսթից դեպի /var/www գրացուցակ: Մենք նաև սահմանել ենք կոնտեյների աշխատանքային գրացուցակը /var/www: Այնուհետև մենք տեղադրում ենք տարբեր նախադրյալներ և փաթեթներ, որոնք անհրաժեշտ են Laravel-ի աշխատանքի համար, ներառյալ PHP ընդլայնումները, ներառյալ mbstring, gd, exif, zip, pdo_mysql և pcntl: Այնուհետև մենք տեղադրում ենք Composer փաթեթի կառավարիչը:

Այնուհետև մենք պատճենում ենք բոլոր ֆայլերը Laravel գրացուցակից դեպի կոնտեյներ և աշխատանքային գրացուցակի վրա թույլտվություններ ենք սահմանում www-data օգտագործողի համար: Սա այն օգտվողն է, որը PHP-ն օգտագործում է լռելյայնորեն Debian հարթակում: Հաջորդը, մենք սահմանում ենք ճիշտ գրելու թույլտվություններ Laravel-ի տեղեկամատյանների, նիստերի և դիտումների դիրեկտորիաների համար:

Եվ վերջապես, մենք բացահայտում ենք 9000 նավահանգիստը PHP-FPM ծառայության համար, որը կօգտագործվի Nginx սերվերի կողմից, և գործարկում ենք PHP հրամանը՝ կոնտեյները գործարկելու համար:

Քայլ 7 - Կարգավորեք PHP-ն

Ստեղծեք PHP գրացուցակը:

$ mkdir ~/laravel/php

Ստեղծեք և բացեք local.ini ֆայլը խմբագրման համար:

$ nano local.ini

Դրա մեջ տեղադրեք հետևյալ կոդը.

upload_max_filesize=40M
post_max_size=40M

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է: Այս հրահանգները սահմանում են բեռնված ֆայլերի առավելագույն չափը: Փոխեք արժեքը՝ ըստ ձեր պահանջների: Դուք կարող եք տեղադրել ցանկացած PHP-ի կոնֆիգուրացիա՝ լռելյայն դիրեկտիվները վերացնելու համար:

Քայլ 8 - Կարգավորեք Nginx-ը

Ստեղծեք Nginx գրացուցակը կայքի կազմաձևման համար:

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

Մենք պետք է ստեղծենք Nginx կազմաձևման ֆայլ, որպեսզի օգտագործենք PHP-FPM որպես FastCGI սերվեր՝ Laravel-ին սպասարկելու համար:

Ստեղծեք և բացեք app.conf ֆայլը խմբագրման համար:

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

Դրա մեջ տեղադրեք հետևյալ կոդը.

server {
    # Redirect any http requests to https
    listen 80;
    listen [::]:80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    index index.php index.html;

    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;

    root /var/www/public;
    client_max_body_size 40m;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    ssl_ecdh_curve secp384r1;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    # OCSP stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;

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

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է:

Վերոնշյալ ֆայլը կարգավորում է Nginx-ը, որպեսզի սպասարկի Laravel կայքի և՛ HTTP, և՛ HTTPS տարբերակները և ինքնաբերաբար վերահղելու ցանկացած HTTP հարցում դեպի HTTPS: Համոզվեք, որ client_max_body_size փոփոխականի արժեքը համապատասխանում է նախորդ քայլում սահմանված վերբեռնման չափին:

PHP տեղորոշման բլոկում fastcgi_pass հրահանգը սահմանում է, որ app ծառայությունը լսում է 9000 պորտի TCP վարդակից: PHP-FPM սերվերը կարող է նաև լսել Unix վարդակից: առավելություն ունի TCP վարդակից: Բայց դա չի աշխատում, եթե ծառայություններն աշխատում են տարբեր հոսթերի վրա, ինչը տեղի է ունենում այստեղ, քանի որ app կոնտեյները աշխատում է ձեր վեբսերվեր կոնտեյներից այլ հոսթի վրա:

Քայլ 9 - Կարգավորեք MySQL-ը

Մենք կկազմաձևենք MySQL-ն, որպեսզի միացնի ընդհանուր հարցումների մատյանը և նշի համապատասխան գրանցամատյանի ֆայլը:

Ստեղծեք MySQL գրացուցակը:

$ mkdir ~/laravel/mysql

Ստեղծեք և բացեք my.cnf ֆայլը խմբագրման համար:

$ nano ~/laravel/my.cnf

Դրա մեջ տեղադրեք հետևյալ կոդը.

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

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է:

Քայլ 10 - Շրջակա միջավայրի ֆայլի կարգավորում

Այժմ, երբ մենք ստեղծել և կարգավորել ենք բոլոր ծառայությունները, ժամանակն է սկսել բեռնարկղերը: Բայց մինչ դա անելը, մենք պետք է կարգավորենք միջավայրի փոփոխականները Laravel-ի համար: Laravel-ը գալիս է լռելյայն միջավայրի ֆայլով՝ .env.example:

Ստեղծեք օրինակ միջավայրի ֆայլի պատճենը:

$ cp .env.example .env

Բացեք .env ֆայլը խմբագրման համար:

$ nano .env

Գտեք DB_CONNECTION-ով սկսվող բլոկը և թարմացրեք փոփոխականների արժեքները ձեր պահանջներին համապատասխան:

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

DB_HOST-ի արժեքը կլինի db ծառայությունը: DB_NAME, DB_USERNAME և DB_PASSWORD-ը կլինեն տվյալների բազայի անունը, օգտանունը և գաղտնաբառը, որը դուք ընտրել եք 4-րդ քայլում Docker-ի կազմման ֆայլում:

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է:

Քայլ 11 - Սկսեք կոնտեյներները և ավարտեք Laravel-ի տեղադրումը

Վերջապես ժամանակն է սկսել բեռնարկղերը:

$ docker compose up -d

Այս հրամանը, երբ առաջին անգամ գործարկվի, կհանի Nginx, MySQL պատկերները և կստեղծի app պատկերը՝ օգտագործելով Dockerfile-ը: ուժեղ> մենք ստեղծել ենք. Գործընթացն ավարտվելուց հետո կարող եք ստուգել ձեր բեռնարկղերի կարգավիճակը՝ օգտագործելով հետևյալ հրամանը.

$ docker ps

Դուք կտեսնեք նմանատիպ արդյունք:

CONTAINER ID   IMAGE            COMMAND                  CREATED       STATUS       PORTS                                                                      NAMES
a57be976c0fa   mysql:latest     "docker-entrypoint.s…"   6 hours ago   Up 6 hours   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp                       db
85e515c4a404   howtoforge/app   "docker-php-entrypoi…"   6 hours ago   Up 6 hours   9000/tcp                                                                   app
8418bbc83bd3   nginx:alpine     "/docker-entrypoint.…"   6 hours ago   Up 6 hours   0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   webserver

Երբ բեռնարկղերը գործարկվեն, ժամանակն է ավարտել Laravel-ի տեղադրումը, օգտագործելով docker compose exec հրամանը՝ բեռնարկղի ներսում հրամաններ գործարկելու համար:

Ստեղծեք հավելվածի բանալի և պատճենեք այն ձեր .env ֆայլում՝ օգտատերերի նիստերը պաշտպանելու և օգտատիրոջ տվյալները գաղտնագրելու համար:

$ docker compose exec app php artisan key:generate

Ստեղծեք Laravel հավելվածի քեշը:

$ docker compose exec app php artisan config:cache

Այս հրամանը բեռնելու է կազմաձևման կարգավորումները /var/www/bootstrap/cache/config.php ֆայլում:

Այցելեք https://example.com ձեր բրաուզերում և կտեսնեք հետևյալ էջը, որը ենթադրում է Laravel-ի հաջող տեղադրում:

Քայլ 12 - Կարգավորեք SSL-ի նորացումը

Այժմ, երբ Laravel կայքը ակտիվ է, ժամանակն է վերանայել SSL կարգավորումները՝ նորացումը կարգավորելու համար: Դրա համար մենք պետք է ստեղծենք սկրիպտներ՝ դադարեցնելու webserver ծառայությունը նախքան նորացումը սկսելը և նորից գործարկենք սերտիֆիկատը թարմացնելուց հետո: Այս նպատակով Certbot-ը տրամադրում է երկու կեռիկ՝ pre_hook և post_hook:

Ստեղծեք SSL գրացուցակ՝ սկրիպտները պահելու համար:

$ mkdir ~/laravel/ssl

Ստեղծեք server-stop.sh սկրիպտը:

$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'

Ստեղծեք server-start.sh սկրիպտը:

$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'

Դարձրեք սցենարները գործարկելի:

$ chmod +x ~/laravel/ssl/server-*.sh

Այժմ մենք պետք է ասենք Certbot-ին, որ օգտագործի այս սցենարները: Բացեք /etc/letsencrypt/renewal/example.com.conf ֆայլը խմբագրման համար:

$ sudo nano /etc/letsencrypt/renewal/example.com.conf

Տեղադրեք հետևյալ տողերը ֆայլի վերջում.

pre_hook = /home/<username>/laravel/ssl/server-stop.sh
post_hook = /home/<username>/laravel/ssl/server-start.sh

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում է:

Ստուգեք Վկայագրի նորացման գործընթացը չոր վազքով:

$ sudo certbot renew --dry-run

Դուք կստանաք նմանատիպ արդյունք, որը հաստատում է հաջողությունը:

Saving debug log to /var/log/letsencrypt/letsencrypt.log

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Processing /etc/letsencrypt/renewal/example.com.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Account registered.
Hook 'pre-hook' ran with output:
 webserver
Simulating renewal of an existing certificate for example.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations, all simulated renewals succeeded:
  /etc/letsencrypt/live/example.com/fullchain.pem (success)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Hook 'post-hook' ran with output:
 webserver

Ձեր SSL վկայագրերն այժմ ինքնաբերաբար կթարմացվեն և կօգտագործվեն Docker կոնտեյների կողմից՝ ձեր Laravel հավելվածը սպասարկելու համար:

Քայլ 13 - Տվյալների միգրացիա և Tinker Console

Այժմ, երբ հավելվածն աշխատում է, կարող եք տեղափոխել ձեր տվյալները և փորձարկել tinker հրամանը: Tinker-ը REPL (Read-Eval-Print Loop) է Laravel-ի համար: tinker հրամանը սկսում է PsySH կոնսոլը Laravel-ով նախապես բեռնված: PsySH-ը գործարկման ժամանակի մշակող վահանակ է և PHP-ի համար ինտերակտիվ վրիպազերծիչ: tinker հրամանը թույլ է տալիս փոխազդել Laravel հավելվածի հետ հրամանի տողից ինտերակտիվ կեղևով:

Փորձարկեք MySQL կապը՝ օգտագործելով բեռնարկղի վրա artisan migrate հրամանը: Այն տվյալների բազայում կստեղծի միգրացիաներ աղյուսակ:

$ docker compose exec app php artisan migrate

Դուք կստանաք հետևյալ արդյունքը.

 INFO  Preparing database.

  Creating migration table .............................................................................................. 32ms DONE

 INFO  Running migrations.

  2014_10_12_000000_create_users_table .................................................................................. 184ms DONE
  2014_10_12_100000_create_password_resets_table ......................................................................... 259ms DONE
  2019_08_19_000000_create_failed_jobs_table ............................................................................ 102ms DONE
  2019_12_14_000001_create_personal_access_tokens_table .................................................................. 46ms DONE

Հաջորդը, գործարկեք PsySH վահանակը՝ օգտագործելով tinker հրամանը:

$ docker compose exec app php artisan tinker

Դուք կստանաք հետևյալ հուշումը.

Psy Shell v0.11.10 (PHP 8.2.1 — cli) by Justin Hileman
>

Ստուգեք MySQL կապը՝ ստանալով ձեր նոր տեղափոխված տվյալները՝ գործարկելով հետևյալ հրամանը վահանակի հուշում:

> \DB::table('migrations')->get();

Դուք կստանաք հետևյալ արդյունքը.

= Illuminate\Support\Collection {#3670
    all: [
      {#3679
        +"id": 1,
        +"migration": "2014_10_12_000000_create_users_table",
        +"batch": 1,
      },
      {#3681
        +"id": 2,
        +"migration": "2014_10_12_100000_create_password_resets_table",
        +"batch": 1,
      },
      {#3682
        +"id": 3,
        +"migration": "2019_08_19_000000_create_failed_jobs_table",
        +"batch": 1,
      },
      {#3683
        +"id": 4,
        +"migration": "2019_12_14_000001_create_personal_access_tokens_table",
        +"batch": 1,
      },
    ],
  }

Վահանակից դուրս գալու համար մուտքագրեք exit:

> exit
   INFO  Goodbye.

Դուք կարող եք օգտագործել tinker՝ ձեր տվյալների շտեմարանների հետ շփվելու և ծառայությունների և մոդելների հետ փորձարկելու համար: Այժմ կարող եք սկսել օգտագործել Laravel-ը հետագա զարգացման համար:

Եզրակացություն

Սա ավարտում է մեր ձեռնարկը, որտեղ դուք կոնտեյներավորել և տեղադրել եք Laravel հավելվածը՝ օգտագործելով Docker, MySQL և PHP: Դուք նաև սպասարկել եք հավելվածը անվտանգ տիրույթի անունով: Եթե ունեք հարցեր, տեղադրեք դրանք ստորև ներկայացված մեկնաբանություններում: