Wprowadzenie
Ciągła integracja (CI) i ciągłe wdrażanie (CD) to obecnie jedne z najpopularniejszych tematów w dziedzinie tworzenia oprogramowania. Aby osiągnąć aspekt CI/CD architektury oprogramowania, programiści korzystają z kontenerów. Kontenery to lekkie, zwirtualizowane, przenośne, zdefiniowane programowo środowiska. W kontenerach oprogramowanie może działać w izolacji od innego oprogramowania uruchomionego na fizycznej maszynie hosta. Ten samouczek skupia się na wykorzystaniu platformy kontenerowej Docker do wdrażania i uruchamiania aplikacji internetowych. Docker pomaga usprawnić proces konfiguracji stosu serwera WWW. W tym samouczku użyjemy stosu LEMP do obsługi aplikacji Laravel .
Stos LEMP łączy system operacyjny Linux, Nginx jako serwer WWW, MySQL jako bazę danych oraz język PHP do skryptowania i dynamicznego przetwarzania. Możesz postępować zgodnie z naszym tutorial on how to install and configure a LEMP stack on Ubuntu. Laravel to jeden z najpopularniejszych frameworków PHP do tworzenia aplikacji internetowych.
Docker dostarcza narzędzie o nazwie Docker Compose do definiowania procesu konfiguracji kontenera Docker. Docker Compose pozwala programistom zdefiniować infrastrukturę ich aplikacji, usługi, wolumeny, sieci i wszelkie zależności w jednym pliku o nazwie docker-compose. Może zarządzać wieloma kontenerami Docker za pomocą swoich poleceń, takich jak docker container create, docker container run itp.
W tym samouczku dowiesz się, how to deploy a Laravel web application with Nginx and MySQL inside a Docker container. Konfiguracje dla całego stosu zostaną zdefiniowane w pliku docker-compose, podobnie jak inne pliki konfiguracyjne dla PHP, MySQL i Nginx. Zaczynajmy!
Najpierw najważniejsze
- Ponieważ jest to praktyczny samouczek, powinieneś mieć zainstalowany system Ubuntu 20.04 jako początkowe środowisko operacyjne. Powinieneś także mieć użytkownika niebędącego administratorem (non-root) z uprawnieniami sudo. Oto step-by-step tutorial to help you set up your Ubuntu server.
- Musisz zainstalować Dockera. Mamy samouczek na temat how to install and operate Docker on Ubuntu 18.04.
- Musisz zainstalować Docker Compose, postępując zgodnie z samouczkiem z oficjalnej Docker documentation.
Krok 1: Pobranie Laravela i instalacja zależności
Pierwszym krokiem jest pobranie kodu Laravela z repozytorium. W rzeczywistych scenariuszach możesz mieć swój kod Laravela w jakimś repozytorium, np. na GitHubie, Bitbuckecie, GitLabie itp. Jednak na potrzeby tego samouczka sklonujemy najnowszą wersję z oficjalnego repozytorium Laravela na GitHub. Repozytorium zawiera plik composera, menedżera zależności na poziomie aplikacji dla PHP. Ponieważ chcemy, aby wszystko działało wewnątrz kontenera Docker, zainstalujemy zależności za pomocą obrazu Docker composer . Pomoże nam to również uniknąć konieczności globalnej instalacji composera na rzeczywistej maszynie hosta. Następnie uruchom terminal.
Przejdź do swojego katalogu domowego:
|
1 |
cd ~ |
Wpisz następujące polecenie, aby sklonować repozytorium do katalogu o nazwie laravel-web. Możesz go nazwać dowolnie. W momencie pisania tego tekstu, po uruchomieniu tego polecenia pobierana jest wersja 8 Laravela. Kiedy uruchomisz to polecenie, prawdopodobnie znajdziesz nowszą wersję:
|
1 |
git clone https://github.com/laravel/laravel.git laravel-web |
Następnie przejdź do katalogu, do którego właśnie sklonowałeś repozytorium:
|
1 |
cd ~/laravel-web |
Wpisz następujące polecenie, aby zamontować katalogi potrzebne dla aplikacji Laravel przy użyciu obrazu composer image:
|
1 |
docker run --rm -v $(pwd):/app composer install |
Flagi -v oraz –rm w poleceniu docker run tworzą tymczasowy kontener, który zostanie zamontowany powiązaniem (bind-mount) do bieżącego katalogu przed jego usunięciem. Polecenie kopiuje zawartość ~/laravel-web do kontenera i zapewnia, że folder vendor utworzony przez composera zostanie skopiowany z powrotem do bieżącego katalogu.
Teraz musisz zmienić właściciela katalogu laravel-web na użytkownika niebędącego rootem. Pozwoli to na pracę z kodem aplikacji jako użytkownik niebędący rootem oraz uruchamianie procesów wewnątrz kontenera w kolejnych krokach. Wprowadź następujące polecenie, aby zmienić właściciela:
|
1 |
sudo chown -R $USER:$USER ~/laravel-web |
Kod Twojej aplikacji jest już na swoim miejscu. Właścicielem katalogu jest użytkownik niebędący rootem, więc możesz przejść do definiowania usług aplikacji w pliku docker-compose.
Krok 2: Utworzenie pliku Docker Compose
Docker Compose upraszcza proces budowania i wdrażania aplikacji. Po zdefiniowaniu konfiguracji i usług możesz łatwo wdrożyć swoją aplikację na dowolnej maszynie hosta, na której zainstalowano Docker i Docker Compose, nie martwiąc się o zależności aplikacji. Co najważniejsze, możesz to zrobić za pomocą tylko jednego polecenia Docker Compose, jak zobaczymy w Kroku 9.
W tym kroku zdefiniujesz plik Docker Compose z konfiguracjami dla serwera WWW, bazy danych i usług aplikacji niezbędnych do wdrożenia aplikacji Laravel.
Pliki Docker Compose to pliki YAML zapisane z rozszerzeniem .yml. Pamiętaj, że prawidłowe wcięcia są niezbędne dla poprawnego pliku Docker Compose. Wprowadź następujące polecenie, aby utworzyć i otworzyć plik w edytorze nano:
|
1 |
nano ~/laravel-web/docker-compose.yml |
Następnie zdefiniujesz w tym pliku trzy usługi: app, webserver i db. Sekcja db definiuje dane uwierzytelniające bazy danych dla Twojej aplikacji, więc upewnij się, że wybierzesz silne hasło mysql_root_password i zastąpisz je w tej sekcji. Skopiuj i wklej następujący kod:
|
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: #Usługa 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/ networks: - app-network #Usługa Nginx webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" networks: - app-network #Usługa 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 networks: - app-network #Sieci Docker networks: app-network: driver: bridge |
Poniżej znajdują się wyjaśnienia definicji usług z powyższego kodu:
- app: Definiuje aplikację Laravel i uruchamia niestandardowy obraz Dockera, cloudsigma.com/php, który zdefiniujemy w Kroku 4. Ustawia również working_dir w kontenerze na /var/www/html.
- webserver: Pobiera obraz nginx:alpine z Dockera i udostępnia porty 80 i 443.
- db: Pobiera obraz mysql:5.7.32 z Dockera i definiuje kilka zmiennych środowiskowych. Obejmują one bazę danych o nazwie laravel_web dla aplikacji oraz hasło roota dla bazy danych. Możesz zmienić nazwę bazy danych na dowolnie wybraną. Pamiętaj, aby zastąpić właściwość MYSQL_ROOT_PASSWORD silnym hasłem. Ta usługa mapuje również port 3306 na hoście na port 3306 w kontenerze.
Właściwość container_name w każdej usłudze definiuje nazwę kontenera odpowiadającego danej usłudze. Jeśli nie zdefiniujesz tej właściwości, Docker wybierze losową nazwę dla każdego kontenera.
Właściwość networks definiuje sieć mostkową o nazwie app-network, która ułatwia komunikację między kontenerami. Sieć mostkowa jest kontrolowana przez mostek programowy, który umożliwia komunikację wyłącznie między kontenerami w tej samej sieci mostkowej. Programowy kontroler mostka instaluje sterowniki, które uniemożliwiają kontenerom w różnych sieciach mostkowych bezpośrednią komunikację ze sobą. Zapewnia to wysoki poziom bezpieczeństwa, ponieważ bezpośrednio mogą komunikować się tylko powiązane usługi. Możesz zdecydować się na zdefiniowanie wielu usług i sieci łączących powiązane funkcje.
Krok 3: Jak utrwalać dane
Twoja aplikacja internetowa będzie przetwarzać i udostępniać dane użytkownikom. W tym kroku przeprowadzimy Cię przez proces definiowania wolumenów i montowań powiązanych dla definicji usług, aby utrwalić dane aplikacji. Docker oferuje niesamowite funkcje, takie jak montowania powiązane oraz wolumeny do utrwalania danych i zapisywania plików konfiguracyjnych aplikacji. Użyjemy ich do skonfigurowania naszej aplikacji Laravel z Dockerem.
Wolumeny są preferowane z różnych powodów, w tym ze względu na oferowanie kopii zapasowych i utrwalanie danych poza cyklem życia kontenera. Montowania powiązane (Bind Mounts) zazwyczaj odwołują się do rzeczywistego katalogu na maszynie hosta. Kiedy tworzysz wolumen, w katalogu pamięci masowej Dockera tworzony jest nowy katalog, którym zarządza Docker. Kiedy tworzysz montowanie powiązane, plik lub katalog wewnątrz maszyny hosta jest montowany w kontenerze (odwoływany za pomocą ścieżki absolutnej). Jest to kluczowe dla naszej aplikacji internetowej, ponieważ po wprowadzeniu zmian w kodzie na maszynie hosta będą one natychmiast dostępne dla kontenera.
Zachowaj ostrożność podczas korzystania z montowań powiązanych. Procesy uruchomione wewnątrz kontenera Docker mogą wprowadzać zmiany w systemie plików hosta i wpływać na procesy spoza Dockera uruchomione na systemie hosta. Chociaż montowania Dockera są potężną funkcją, należy pamiętać o tych konsekwencjach dla bezpieczeństwa.
Mając to na uwadze, zobaczmy, jak możemy wykorzystać te dwie funkcje w naszej konfiguracji. Najpierw zdefiniujemy wolumen do utrwalania bazy danych MySQL. W utworzonym przez nas pliku Docker Compose, pod usługą db, dodaj właściwość volumes, jak wyróżniono poniżej:
|
1 2 3 4 5 6 7 8 |
#Usługa MySQL db: ... volumes: - dbdata:/var/lib/mysql/ networks: - app-network ... |
Zgodnie z definicją, wolumen dbdata będzie utrwalał zawartość katalogu /var/lib/mysql. Ułatwia to tworzenie kopii zapasowych i pozwala na restartowanie usług bez utraty danych. Następnie należy dodać definicję wolumenów na końcu pliku Docker Compose, aby była dostępna dla wszystkich usług. Wprowadź następujący fragment kodu na dole pliku:
|
1 2 3 4 |
#Wolumeny volumes: dbdata: driver: local |
Aby połączyć się z bazą danych MySQL, musisz podać dane uwierzytelniające. W tym celu zdefiniuj montowanie powiązane, dodając następujący wyróżniony fragment kodu do usługi db pod właściwością volumes:
|
1 2 3 4 5 6 7 |
#Usługa MySQL db: ... volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf ... |
Kod powiązuje ~/laravel-web/mysql/my.cnf z /etc/mysql/my.cnf w kontenerze. Powiązany plik to plik konfiguracyjny MySQL, który utworzymy w Kroku 7.
Kontener musi używać serwera Nginx do obsługi kodu aplikacji. Dlatego w tym celu zdefiniujemy dwa montowania powiązane (jedno dla pliku konfiguracyjnego Nginx i jedno dla kodu aplikacji) w ramach usługi webserver. Dodaj następujący fragment kodu dla definicji wolumenów pod usługą webserver:
|
1 2 3 4 5 6 7 8 |
#Usługa Nginx webserver: ... volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network |
Ta linia – ./:/var/www/html montuje kod aplikacji z katalogu ~/laravel-web do katalogu /var/www/html wewnątrz kontenera. W przypadku drugiego montowania typu bind, plik konfiguracyjny dla Nginx zostanie utworzony w ~/laravel-web/nginx/conf.d/. Zostanie on zamontowany do /etc/nginx/conf.d/ wewnątrz kontenera. Dzięki temu można aktualizować plik konfiguracyjny na maszynie hosta w zależności od potrzeb. Plik konfiguracyjny Nginx utworzymy w Kroku 6.
Aby zmiany w kodzie były automatycznie odzwierciedlane w kontenerze, montujemy kod aplikacji do kontenera za pomocą bind mount. Przyspiesza to proces wdrażania. W związku z tym dodaj następujący wyróżniony fragment kodu do usługi app:
|
1 2 3 4 5 6 7 8 |
#Usługa PHP app: ... volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network |
Druga linia montuje plik konfiguracyjny php, który utworzymy w Kroku 5 wewnątrz pliku ~/laravel-web/php/laravel.ini do /usr/local/etc/php/conf.d/laravel.ini wewnątrz kontenera.
Twój kompletny plik Docker Compose powinien teraz wyglądać następująco:
|
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: #Usługa 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 #Usługa 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 #Usługa 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 #Sieci Docker networks: app-network: driver: bridge #Wolumeny volumes: dbdata: driver: local |
Jeśli wszystko wygląda w porządku, naciśnij Ctrl + O, aby zapisać plik. Następnie naciśnij Ctrl + X, aby wyjść z edytora. W tym momencie powinieneś być w stanie zbudować niestandardowy obraz Dockera dla swojej aplikacji za pomocą pliku Docker Compose.
Krok 4: Utworzenie pliku Dockerfile
Dockerfile zawiera instrukcje, których Docker może użyć do budowania niestandardowych obrazów Dockera. Może również instalować wymagane oprogramowanie i konfigurować niezbędne ustawienia dla Twojej aplikacji. Określają one środowisko wewnątrz kontenera, w którym będzie znajdować się kod Twojej aplikacji. Utworzone obrazy możesz przesłać do docker hub w celu ich udostępnienia lub umieścić je w innych prywatnych rejestrach.
Utworzymy plik Dockerfile, który określi instrukcje budowania obrazu aplikacji Laravel. Użyj nano, aby utworzyć Dockerfile w katalogu ~/laravel-web:
|
1 |
nano ~/laravel-web/Dockerfile |
W otwartym edytorze dodaj następujący kod:
|
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 # Kopiowanie composer.lock i composer.json do katalogu roboczego COPY composer.lock composer.json /var/www/html/ # Ustawienie katalogu roboczego WORKDIR /var/www/html/ # Instalacja zależności dla oprogramowania systemu operacyjnego 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 # Czyszczenie pamięci podręcznej RUN apt-get clean && rm -rf /var/lib/apt/lists/* # Instalacja rozszerzeń dla 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 # Instalacja composera (menedżera pakietów php) RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer # Kopiowanie zawartości istniejącego katalogu aplikacji do katalogu roboczego COPY . /var/www/html # Przypisanie uprawnień do katalogu roboczego użytkownikowi www-data RUN chown -R www-data:www-data \ /var/www/html/storage \ /var/www/html/bootstrap/cache # Udostępnienie portu 9000 i uruchomienie serwera php-fpm (dla FastCGI Process Manager) EXPOSE 9000 CMD ["php-fpm"] |
Dockerfile najpierw tworzy obraz na podstawie php:7.4-fpm obrazu Docker. Jest to obraz oparty na systemie Debian z zainstalowaną implementacją PHP FastCGI (PHP-FPM) . Aby Laravel działał poprawnie, wymaga innych rozszerzeń PHP, takich jak mcrypt, pdo_mysql, mbstring i imagick, które skrypt instaluje. Następnie instaluje composer – menedżer pakietów PHP. Kontener użyje go do zainstalowania zależności PHP dla Laravela.
Możesz użyć dyrektywy RUN do zdefiniowania poleceń, takich jak instalacja, aktualizacja i konfiguracja ustawień wewnątrz kontenera. Przypisuje ona również uprawnienia użytkownika. Dyrektywa WORKDIR określa katalog roboczy, w tym przypadku /var/www/html. Skrypt uruchamia polecenie CHOWN, aby przypisać uprawnienia do katalogu /var/www/html użytkownikowi www-data.
Przed ostatecznym zbudowaniem obrazu należy udostępnić port, aby umożliwić dostęp do aplikacji działającej wewnątrz kontenera. Polecenie EXPOSE udostępnia port 9000 dla serwera php-fpm. Ostatnim poleceniem do uruchomienia jest dyrektywa CMD. Uruchamia ona php-fpm w celu uruchomienia serwera.
Możesz teraz nacisnąć Ctrl + O, aby zapisać plik. Następnie naciśnij Ctrl + X, aby wyjść z edytora.
Krok 5: Konfiguracja PHP
W tym kroku skonfigurujemy usługę php do przetwarzania przychodzących żądań z Nginx. Utworzysz plik laravel.ini wewnątrz katalogu php. Ten plik będzie zawierał konfiguracje PHP. Jest to plik, który został zamontowany powiązaniem (bind-mounted) do /usr/local/etc/php/conf.d/laravel.ini w kontenerze w Kroku 3. Konfiguracje w tym pliku nadpisują domyślny plik php.ini, który jest zwykle odczytywany przez PHP podczas uruchamiania. Wprowadź następujące polecenie, aby utworzyć katalog php:
|
1 |
mkdir ~/laravel-web/php |
Utwórz i otwórz plik laravel.ini wewnątrz katalogu php, wprowadzając następujące polecenie:
|
1 |
nano ~/laravel-web/php/laravel.ini |
Domyślny plik php.ini ma limit przesyłania ustawiony na 2M. Jako przykład pokażemy, jak dostosować i ustawić konfiguracje php, zmieniając wartość dozwolonego limitu przesyłania, na wypadek gdybyś chciał przesyłać większe pliki. Wprowadź następujące linie kodu wewnątrz pliku:
|
1 2 |
upload_max_filesize=80M post_max_size=80M |
To ustawia limit przesyłania i pozwala na przesyłanie plików o łącznym rozmiarze nie większym niż 80MB. Możesz dodać inne konfiguracje php wewnątrz pliku laravel.ini, aby nadpisać domyślne konfiguracje php. Teraz zapisz i zamknij plik.
Krok 6: Konfiguracja Nginx
W tym kroku skonfigurujemy Nginx do korzystania z usługi php, którą zdefiniowaliśmy wcześniej. Będzie ona używać PHP-FPM jako serwer FastCGI do serwowania dynamicznej zawartości. Serwer FastCGI to oprogramowanie, które umożliwia interaktywnym programom interfejs z serwerem WWW.
Jak zdefiniowaliśmy w pliku docker-compose w Kroku 3, utworzymy plik konfiguracyjny Nginx app.conf wewnątrz katalogu ~/laravel-web/nginx/conf.d/. Najpierw wprowadź następujące polecenie, aby utworzyć katalog:
|
1 |
mkdir -p ~/laravel-web/nginx/conf.d |
Następnie utwórz i otwórz plik app.conf za pomocą nano, wprowadzając następujące polecenie:
|
1 |
nano ~/laravel-web/nginx/conf.d/app.conf |
Dodaj następujący kod konfiguracji Nginx do pliku:
|
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 odczytuje pliki konfiguracyjne zwane blokami serwera (server blocks), aby wiedzieć, który katalog powinien być serwowany odwiedzającemu stronę na podstawie adresu URL. Aby dowiedzieć się więcej, przeczytaj o konfigurowaniu bloków serwera w naszym samouczku dotyczącym instalacji Nginx na Ubuntu 18.04. Zdefiniowane dyrektywy służą następującym celom:
- listen – Definiuje port, na którym serwer będzie nasłuchiwał przychodzących żądań, którym zazwyczaj jest port 80.
- error_log & access_log – Definiuje pliki do zapisywania logów aplikacji.
- root – Definiuje ścieżkę katalogu głównego (webroot), czyli katalog, który będzie obsługiwał wszelkie żądania kierowane do serwera z Internetu.
W bloku location dla php dyrektywa fastcgi_pass określa, że usługa app nasłuchuje na gnieździe TCP na porcie 9000 (który został zdefiniowany w pliku Dockerfile). Kieruje to serwer PHP-FPM do nasłuchiwania przez sieć, a nie na gnieździe Unix. Choć gniazdo Unix może mieć niewielką przewagę prędkości nad gniazdem TCP, nie posiada protokołu sieciowego, przez co pomija stos sieciowy.
Gniazdo Unix (Unix socket) byłoby bardziej odpowiednie w scenariuszach, w których hosty znajdują się na jednej maszynie. Jeśli jednak usługi działają na różnych hostach, gniazdo TCP ma tę zaletę, że umożliwia łączenie usług, które są rozproszone. W naszym przypadku kontener aplikacji działa na innym hoście niż kontener serwera WWW. W związku z tym gniazdo TCP jest najbardziej odpowiednie dla naszej konfiguracji.
Możesz teraz nacisnąć Ctrl + O, aby zapisać plik, a następnie Ctrl + X, aby wyjść z edytora. Zmiany wprowadzone w katalogu nginx/conf.d/ zostaną automatycznie odzwierciedlone w kontenerze serwera WWW dzięki montowaniu powiązanemu (bind mount), które dodałeś w pliku Docker Compose w Krok 3.
Krok 7: Skonfiguruj MySQL
Po skonfigurowaniu Nginx do współpracy z PHP, możemy teraz skonfigurować MySQL do przechowywania i dostarczania dynamicznych danych do PHP. Skonfigurowaliśmy już plik Docker Compose tak, aby instalował niezbędne rozszerzenia do komunikacji między PHP a MySQL. Utworzymy plik konfiguracyjny MySQL my.cnf wewnątrz folderu mysql, który zostanie powiązany (bind-mounted) z /etc/mysql/my.cnf, tak jak zdefiniowaliśmy to w sekcji usługi db w Docker Compose w Krok 3.
Ustawienia konfiguracyjne i zmiany w MySQL można wprowadzać w pliku my.cnf w dowolnym momencie. Powinny one zostać natychmiast odzwierciedlone wewnątrz kontenera. Najpierw utwórz katalog, wprowadzając następujące polecenie:
|
1 |
mkdir ~/laravel-web/mysql |
Następnie utwórz i otwórz plik w edytorze nano, wprowadzając następujące polecenie:
|
1 |
nano ~/laravel-web/mysql/my.cnf |
Wprowadź poniższy fragment kodu, aby włączyć dziennik zapytań (query log) i określić lokalizację pliku dziennika zapytań:
|
1 2 3 |
[mysqld] general_log = 1 general_log_file = /var/lib/mysql/general.log |
Definiując właściwość general_log jako 1, zezwalasz na ogólne dzienniki (general logs). Właściwość general_log_file określa lokalizację pliku dziennika. Naciśnij Ctrl + O, aby zapisać plik, a następnie naciśnij Ctrl + X, aby wyjść z edytora.
Krok 8: Ustaw zmienne środowiskowe Laravel
Do tego momentu wszystkie usługi i ustawienia konfiguracyjne są kompletne. W związku z tym moglibyśmy już wdrożyć nasze kontenery. Istnieje jednak ważny krok, który należy wykonać, zanim nasza aplikacja internetowa będzie rzeczywiście użyteczna – zmienne środowiskowe. Framework Laravel oczekuje pliku o nazwie .env, którego używa do definiowania swojego środowiska. Domyślnie Laravel zawiera plik .env.example, który można skopiować do .env, a następnie zmodyfikować zmienne, wprowadzając własne dane. Wprowadź następujące polecenie, aby skopiować plik:
|
1 |
cp .env.example .env |
Po skopiowaniu otwórz plik za pomocą nano, aby go zmodyfikować:
|
1 |
nano .env |
Oto zrzut ekranu przedstawiający, jak może wyglądać ten plik:
Kolejnym krokiem jest modyfikacja zmiennych w bloku DB_CONNECTION w pliku, zgodnie z dotychczasowymi ustawieniami. Zaktualizuj je w następujący sposób:
- DB_HOST to db kontener bazy danych.
- DB_DATABASE to laravel_web.
- DB_USERNAME to nazwa użytkownika bazy danych. Wybierz dowolną nazwę, ale na potrzeby tego samouczka użyjmy laraveldocker.
- DB_PASSWORD to silne hasło, którego powyższy użytkownik będzie używał do logowania się do bazy danych, więc wybierz silne hasło. W Kroku 10, utworzymy tego użytkownika z hasłem wybranym w tym miejscu.
Po zaktualizowaniu wartości Twój blok DB_CONNECTION powinien wyglądać następująco:
Zapisz i zamknij plik.
Krok 9: Uruchom kontenery Docker
Na tym etapie wszystkie Twoje usługi i konfiguracje są zdefiniowane w pliku Docker Compose. Wystarczy jedno polecenie, aby uruchomić wszystkie kontenery, utworzyć wolumeny, połączyć sieci oraz skonfigurować i zbudować aplikację. Wprowadź następujące polecenie w terminalu:
|
1 |
docker-compose up -d |
Gdy uruchamiasz polecenie docker-compose up po raz pierwszy, pobiera ono wszystkie niezbędne obrazy Dockera. Jeśli konfigurujesz infrastrukturę na swoim lokalnym komputerze, może to zająć trochę czasu. Po pobraniu obrazów Compose tworzy kontenery. Flaga -d instruuje Dockera, aby uruchomił kontenery w tle. Jeśli proces zakończy się pomyślnie, w terminalu powinieneś zobaczyć coś takiego:
Wpisz następujące polecenie w terminalu, aby wyświetlić listę wszystkich uruchomionych kontenerów:
|
1 |
docker ps |
Powinno to wyświetlić coś podobnego do poniższego zrzutu ekranu, ze szczegółami dotyczącymi kontenerów app, webserver i db:
- CONTAINER ID – Unikalny identyfikator dla każdego kontenera.
- NAMES – Nazwa usługi powiązana z każdym kontenerem, zdefiniowana w pliku Docker Compose. (Możesz użyć identyfikatora kontenera lub jego nazwy, aby uzyskać dostęp do kontenera).
- IMAGE – Nazwa obrazu dla każdego kontenera.
- STATUS – Wyświetla informacje o stanie kontenera (może być zatrzymany, uruchomiony lub restartowany).
- PORTS – Pokazuje porty, które kontener udostępnia.
Docker Compose udostępnia polecenie o nazwie exec, którego można użyć do uruchamiania poleceń terminala lub uzyskania dostępu do wiersza poleceń wewnątrz kontenera. Najpierw chcemy uruchomić kilka poleceń wewnątrz kontenera app, który jest kontenerem uruchamiającym aplikację Laravel.
Docker udostępnia polecenie umożliwiające dostęp do wiersza poleceń kontenera. Jego składnia jest następująca: docker-compose exec container_name bash. Aby uzyskać dostęp do wiersza poleceń kontenera app, wpisz następujące polecenie:
|
1 |
docker-compose exec app bash |
Po wejściu do wiersza poleceń kontenera możesz uruchomić niektóre polecenia konfiguracyjne Laravel Artisan. Wpisz następujące polecenie, aby wygenerować klucz laravel i zapisać go w pliku .env:
|
1 |
php artisan key:generate |
Po ustawieniu klucza środowiskowego możesz uruchomić następujące polecenie, aby zapisać ustawienia konfiguracyjne w pamięci podręcznej:
|
1 |
php artisan config:cache |
Konfiguracje są przechowywane w pliku /var/www/html/bootstrap/cache/config.php wewnątrz kontenera. Możesz nacisnąć Ctrl + D, aby wyjść z terminala kontenera.
Aby potwierdzić, że aplikacja Laravel została wdrożona i działa, odwiedź publiczny adres IP swojego serwera w przeglądarce (http://your_server_public_ip). Powinieneś zobaczyć stronę powitalną nowej instalacji Laravela:
Krok 10: Skonfiguruj użytkownika MySQL
W tym kroku utworzymy użytkownika bazy danych dla bazy danych MySQL laravel_web, którą określiliśmy w pliku docker-compose. Kiedy uruchomiłeś polecenie budowania kontenera w Step 9, MySQL został zainstalowany, ale utworzył jedynie domyślne konto administracyjne root, które ma nieograniczone uprawnienia do bazy danych. Aby uniknąć korzystania z użytkownika root, utworzymy dedykowanego użytkownika, laraveldocker, do użytku w aplikacji. Jest to użytkownik określony w zmiennych środowiskowych w Step 8. Uzyskaj dostęp do wiersza poleceń wewnątrz terminala, wpisując następujące polecenie:
|
1 |
docker-compose exec db bash |
Po wejściu do kontenera zaloguj się do MySQL, wpisując następujące polecenie:
|
1 |
mysql -u root -p |
W monicie o hasło wpisz hasło ustawione dla usługi db w pliku docker-compose w Step 2.
Po zalogowaniu się do wiersza poleceń MySQL sprawdź, czy widzisz bazę danych określoną w pliku docker-compose, wpisując następujące polecenie SQL:
|
1 |
show databases; |
Powinieneś zobaczyć bazę danych laravel_web lub inną nazwę określoną w Twojej konfiguracji:
Następnie tworzymy użytkownika i hasło dla bazy danych laravel_web. Muszą to być te same dane, które podałeś w pliku .env w Step 8. Wpisz następujące polecenie, aby utworzyć użytkownika i hasło oraz nadać mu wszystkie uprawnienia:
|
1 |
GRANT ALL ON laravel_web.* TO 'laraveldocker'@'%' IDENTIFIED BY 'your_strong_laravel_docker_password'; |
Aby zmiany odniosły natychmiastowy skutek, wprowadź następujące polecenie, aby odświeżyć uprawnienia:
|
1 |
FLUSH PRIVILEGES; |
To kończy konfigurację użytkownika MySQL. Wyjdź z wiersza poleceń MySQL, wpisując exit i naciskając enter. Na koniec wyjdź z kontenera db, naciskając Ctrl + D.
Krok 11: Przetestowanie komunikacji między kodem aplikacji Laravel a bazą danych MySQL
Do tego kroku wszystko działało poprawnie. Chcemy jednak potwierdzić, że kod Laravel w kontenerze app może komunikować się z bazą danych MySQL w kontenerze db. Najpierw uzyskaj dostęp do terminala kontenera app, wprowadzając następujące polecenie:
|
1 |
docker-compose exec app bash |
Następnie należy uruchomić polecenie laravel migration, które tworzy tabele:
|
1 |
php artisan migrate |
W terminalu powinieneś zobaczyć proces migracji, podczas którego Laravel tworzy domyślne tabele:
Następnie przetestujemy, czy możemy uzyskać dostęp do bazy danych z poziomu Laravel. Laravel domyślnie zawiera Tinker, który pozwala na interakcję z całą aplikacją z poziomu wiersza poleceń, w tym na dostęp do bazy danych, uruchamianie zadań, eloquent ORM i nie tylko. Możemy użyć narzędzia Tinker do przeglądania danych w tabeli migracji. Wprowadź następujące polecenie, aby uzyskać dostęp do Tinker:
|
1 |
php artisan tinker |
Po przejściu do wiersza poleceń Tinker możesz wyświetlić listę tabel utworzonych przez polecenie migrate, wprowadzając następujące polecenie:
|
1 |
\DB::select('show tables'); |
Poniższy zrzut ekranu przedstawia wynik, czyli tabele znajdujące się obecnie w bazie danych laravel_web:
Możesz pobrać dane z tabeli, określając jej nazwę. Na przykład możesz pobrać dane z tabeli migrations, wprowadzając następujące polecenie:
|
1 |
\DB::table('migrations')->get(); |
Polecenie zwraca następujący wynik:
Z powyższego wyniku wynika, że Twoja aplikacja Laravel jest dobrze skonfigurowana i może komunikować się z bazą danych. Możesz eksperymentować z kolejnymi poleceniami, takimi jak tworzenie modeli, uruchamianie zadań i nie tylko. Możesz wyjść z wiersza poleceń Tinker, naciskając Ctrl + D.
Podsumowanie
W tym samouczku wdrożyłeś aplikację Laravel ze stosem LEMP wewnątrz kontenera Docker. Przetestowałeś aplikację, uzyskując dostęp do interfejsu internetowego, a także łącząc się z bazą danych za pomocą Laravel Tinker. Miałeś okazję przekonać się o możliwościach Docker Compose. Pozwala on na utworzenie grupy kontenerów Docker zdefiniowanych w jednym pliku, które można następnie uruchomić za pomocą jednego polecenia.
Jeśli chcesz lepiej zapoznać się z kontenerami, zapoznaj się z naszym samouczkiem, który pokazuje, jak czyścić zasoby Dockera – obrazy, kontenery i wolumeny oraz naszym szczegółowym omówieniem narzędzia Kubernetes.
Możesz również odwiedzić nasz blog, aby dowiedzieć się więcej o Dockerze i Continuous Integration oraz Continuous Deployment.
Powodzenia!
Komentarze
Brak komentarzy. Bądź pierwszy.