← Blog
Laravel6 min czytania

Konfiguracja Laravel Octane w środowisku Docker

Laravel Octane uruchamia aplikację w trybie long-running na serwerach Swoole lub RoadRunner, eliminując bootstrap frameworka przy każdym żądaniu HTTP. Pokazujemy kompletną konfigurację w Dockerze.

Wprowadzenie

Laravel Octane to narzędzie, które wprowadza tryb działania long-running w aplikacjach Laravel, umożliwiając ich uruchomienie w środowisku zoptymalizowanym pod kątem wydajności. Octane obsługuje serwery Swoole i RoadRunner, które eliminują potrzebę wielokrotnego uruchamiania frameworka przy każdym żądaniu HTTP, co znacząco przyspiesza ładowanie aplikacji.

W tym artykule pokażemy, jak skonfigurować Laravel Octane w środowisku Docker, aby przyspieszyć działanie API.

Wymagania wstępne

  • Docker oraz Docker Compose — upewnij się, że masz zainstalowane te narzędzia na swoim serwerze.
  • Laravel 8+ — Octane wymaga wersji Laravel 8 lub nowszej.
  • Composer — do instalacji Octane.

Krok 1: instalacja Laravel Octane

1. Przejdź do katalogu swojej aplikacji Laravel:

cd /path/to/your/laravel-app

2. Zainstaluj Octane przy użyciu Composera:

composer require laravel/octane

3. Uruchom komendę do instalacji Octane, aby wygenerować podstawową konfigurację:

php artisan octane:install

4. Po zainstalowaniu Octane zapyta, czy chcesz wybrać serwer. Możesz wybrać Swoole lub RoadRunner. W tym przewodniku pokażemy konfigurację z RoadRunnerem.

Krok 2: tworzenie pliku docker-compose.yml

Poniżej znajduje się konfiguracja docker-compose.yml, która tworzy środowisko z serwerem aplikacyjnym Octane opartym o RoadRunnera. Ustawienia zawierają również konfigurację PostgreSQL i Redis jako usług wspierających aplikację.

Plik docker-compose.yml

services:
  php:
    build: php
    working_dir: /var/www/api
    container_name: ${PROJECT_NAME}-php
    ports:
      - "80"
    volumes:
      - ./web:/var/www/api
      - ./php/php.ini:/usr/local/etc/php/php.ini
      - ./php/laravel-worker.conf:/etc/supervisor/conf.d/laravel-worker.conf
      - ./logs/supervisor:/var/log/supervisor
    restart: always
    environment:
      VIRTUAL_HOST: ${PROJECT_DOMAIN}
      LETSENCRYPT_HOST: ${PROJECT_DOMAIN}
      CERT_NAME: ${PROJECT_DOMAIN}
    depends_on:
      - db
      - redis
  redis:
    image: redis:latest
    container_name: ${PROJECT_NAME}-redis
    ports:
      - '6379'
    volumes:
      - redis-data:/data
  db:
    container_name: ${PROJECT_NAME}-db
    image: postgres:latest
    restart: always
    ports:
      - '5432'
    volumes:
      - db:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_USER=${DB_USERNAME}
      - POSTGRES_DB=${DB_DATABASE}

networks:
  default:
    name: proxy-network
    external: true

Plik .env

PROJECT_NAME=api
PROJECT_DOMAIN=api.twojadomena.pl
DB_DATABASE=api
DB_USERNAME=api
DB_PASSWORD=zmien-to-haslo

Krok 3: stworzenie plików kontenera php

Tworzymy katalog php i umieszczamy w nim następujące pliki:

Dockerfile

FROM php:8.2-fpm

RUN apt-get update --fix-missing

ADD https://github.com/mlocati/docker-php-extension-installer/releases/latest/download/install-php-extensions /usr/local/bin/

RUN chmod +x /usr/local/bin/install-php-extensions && sync && \
    install-php-extensions mbstring pdo_mysql zip exif pcntl gd memcached

RUN apt-get update && apt-get install -y \
    libpq-dev \
    build-essential \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    unzip \
    git \
    curl \
    lua-zlib-dev \
    libmemcached-dev \
    nginx \
    supervisor \
    librabbitmq-dev \
    npm \
    libxml2-dev \
    && apt-get install -y libmagickwand-dev \
    && pecl install imagick \
    && docker-php-ext-enable imagick

RUN pecl install igbinary \
    && rm -rf /tmp/pear \
    && docker-php-ext-enable igbinary

RUN mkdir -p /tmp/pear \
    && cd /tmp/pear \
    && pecl bundle redis \
    && cd redis \
    && phpize . \
    && ./configure --enable-redis-igbinary \
    && make \
    && make install \
    && cd ~ \
    && rm -rf /tmp/pear \
    && docker-php-ext-enable redis

RUN docker-php-ext-install sockets

RUN docker-php-ext-install soap

RUN pecl install amqp \
    && docker-php-ext-enable amqp

RUN docker-php-ext-install pdo_pgsql pgsql

RUN npm install --save-dev chokidar

RUN curl --silent --show-error "https://getcomposer.org/installer" | php -- --install-dir=/usr/local/bin --filename=composer

RUN groupadd -g 1000 www
RUN useradd -u 1000 -ms /bin/bash -g www www

RUN apt-get install -y cron

RUN touch /var/log/schedule.log
RUN chmod 755 /var/log/schedule.log

ADD scheduler /etc/cron.d/scheduler

RUN crontab /etc/cron.d/scheduler

COPY . /var/www/api

COPY --chown=www:www . /var/www/api

CMD ["/usr/bin/supervisord","-n"]

scheduler

* * * * * cd /var/www/api && php artisan schedule:run >> /var/log/schedule.log 2>&1

laravel-worker.conf

[supervisord]
nodaemon=true

[program:octane]
command=php /var/www/api/artisan octane:start --server=roadrunner --host=0.0.0.0 --port=80
autostart=true
autorestart=true
user=www
stdout_logfile=/var/log/supervisor/octane.log
stderr_logfile=/var/log/supervisor/octane-error.log

[program:laravel-queue]
command=php /var/www/api/artisan queue:work --tries=3 --max-time=3600
autostart=true
autorestart=true
numprocs=2
user=www
stdout_logfile=/var/log/supervisor/queue.log

[program:cron]
command=cron -f
autostart=true
autorestart=true

php.ini

error_reporting=E_ALL & ~E_DEPRECATED & ~E_STRICT & ~E_NOTICE & ~E_WARNING
display_errors=On
log_errors=On
upload_max_filesize=128M
post_max_size = 128M

Krok 4: pobranie projektu do katalogu web

Utworzenie katalogu:

mkdir web

Sklonowanie repozytorium do katalogu web:

git clone git@hypedevgroup.pl:hypedev-group/api.git web

Podsumowanie

Dzięki tej konfiguracji masz zoptymalizowaną infrastrukturę z Laravel Octane działającym na serwerze RoadRunner w Dockerze, z obsługą PostgreSQL i Redis. Konfiguracja ta:

  • Umożliwia łatwą integrację z Nginx Proxy i automatycznym SSL (dzięki zmiennym środowiskowym VIRTUAL_HOST, LETSENCRYPT_HOST, CERT_NAME).
  • Pozwala na wysoką wydajność aplikacji Laravel dzięki uruchomieniu Octane na serwerze RoadRunner.
  • Ułatwia zarządzanie komponentami aplikacji i obsługę zależności dzięki Docker Compose.

Po uruchomieniu za pomocą docker-compose up -d aplikacja powinna działać na https://<domena> z wykorzystaniem zalet Octane, co znacząco przyspieszy obsługę żądań HTTP.

← Wszystkie artykuły