Cara Menginstal dan Menyiapkan Laravel dengan Docker Compose pada Ubuntu 20.04

Pengantar

Kontainerisasi aplikasi mengacu pada suatu proses adaptasi aplikasi dan komponennya dengan tujuan agar dapat menjalankannya dalam lingkungan ringan yang dikenal sebagai kontainer. Lingkungan tersebut terisolasi dan dapat dibuang, serta dapat dimanfaatkan lebih lanjut untuk pengembangan, pengujian, dan penyebaran aplikasi hingga produksi.

Dalam panduan ini, kita akan menggunakan Docker Compose untuk melakukan kontainerisasi aplikasi Laravel sebagai pengembangan. Ketika selesai, Anda akan memiliki aplikasi Laravel demo yang berjalan di tiga kontainer layanan terpisah:

• Layanan app yang menjalankan PHP7.4-FPM;
• Layanan db yang menjalankan MySQL 5.7;
• Layanan nginx yang menggunakan layanan app untuk mengurai kode PHP sebelum menyajikan aplikasi Laravel ke pengguna akhir.

Untuk mengizinkan proses pengembangan yang lebih efisien dan memfasilitasi pengawakutuan aplikasi, kita akan membuat berkas aplikasi tetap sinkron menggunakan volume bersama. Kita juga akan melihat cara menggunakan perintah docker-compose exec untuk menjalankan Composer dan Artisan di kontainer app.

Prasyarat

• Akses ke mesin lokal Ubuntu 20.04 atau server pengembangan sebagai pengguna non-root dengan privilese sudo. Jika Anda menggunakan server jauh, Anda disarankan untuk memiliki firewall aktif yang terinstal. Untuk menyiapkan ini, lihat Panduan Penyiapan Server Awal untuk Ubuntu 20.04 dari kami.
• Docker yang terinstal di server, dengan mengikuti Langkah 1 dan 2 dari Cara Menginstal dan Menggunakan Docker pada Ubuntu 20.04.
• Docker Compose yang terinstal di server, dengan mengikuti Langkah 1 dari Cara Menginstal dan Menggunakan Docker Compose pada Ubuntu 20.04.

Langkah 1 — Memperoleh Aplikasi Demo

Untuk memulai, kita akan mengambil aplikasi Laravel demo dari repositori Github. Kita tertarik dengan cabang tutorial-01, yang mengandung aplikasi Laravel dasar yang telah kita ciptakan dalam panduan pertama dari seri ini.

Untuk memperoleh kode aplikasi yang kompatibel dengan tutorial ini, unduh rilis tutorial-1.0.1 ke direktori rumah dengan:

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

Kita akan memerlukan perintah unzip untuk membongkar kode aplikasi. Jika Anda belum menginstal paket ini sebelumnya, lakukan sekarang dengan:

sudo apt update
sudo apt install unzip

Sekarang, lakukan unzip konten aplikasi dan ganti nama direktori yang belum dibongkar untuk memudahkan akses:

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

Bernavigasilah ke direktori travellist-demo:

cd travellist-demo

Dalam langkah selanjutnya, kita akan menciptakan berkas konfigurasi .env untuk menyiapkan aplikasi.

Langkah 2 — Menyiapkan Berkas .env Aplikasi

Berkas konfigurasi Laravel terletak di dalam direktori yang bernama config, di dalam direktori root aplikasi. Sebagai tambahan, berkas .env digunakan untuk menyiapkan konfigurasi dependen lingkungan, seperti kredensial dan informasi apa pun yang mungkin bervariasi di antara penyebaran. Berkas ini tidak disertakan dalam kontrol revisi.

Nilai-nilai yang terkandung di dalam berkas .env akan lebih diutamakan daripada nilai-nilai yang ditetapkan dalam berkas konfigurasi reguler yang terletak di direktori config. Setiap instalasi pada lingkungan baru membutuhkan berkas lingkungan yang dibuat khusus untuk menentukan hal-hal seperti pengaturan koneksi basis data, opsi awakutu, URL aplikasi, di antara hal-hal lainnya yang mungkin dapat bervariasi tergantung pada lingkungan aplikasi yang berjalan.

Sekarang kita akan menciptakan berkas .env baru untuk menyesuaikan opsi konfigurasi lingkungan pengembangan yang kita siapkan. Laravel disertakan dengan berkas .env contoh yang dapat kita salin untuk menciptakan berkas sendiri:

cp .env.example .env

Buka berkas ini menggunakan nano atau editor teks pilihan Anda:

nano .env

Berkas .env saat ini dari aplikasi demo travellist berisi pengaturan untuk menggunakan basis data MySQL lokal, dengan 127.0.0.1 sebagai hos basis data. Kita perlu memperbarui variabel DB_HOST, sehingga mengarah ke layanan basis data yang akan kita ciptakan dalam lingkungan Docker. Dalam panduan ini, kita akan menyebut layanan basis data kita db. Lanjutkan dan ganti nilai yang tercantum di DB_HOST dengan nama layanan basis data:

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

LOG_CHANNEL=stack

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

Silakan mengubah nama basis data, nama pengguna, dan kata sandi, jika Anda ingin. Variabel-variabel ini akan digunakan dalam langkah selanjutnya saat kita akan menyiapkan berkas docker-compose.yml untuk mengonfigurasi layanan kita.

Simpan berkas itu saat Anda selesai mengedit. Jika menggunakan nano, Anda dapat melakukannya dengan menekan Ctrl+x, lalu Y, dan Enter untuk mengonfirmasi.

Langkah 3 — Menyiapkan Dockerfile Aplikasi

Meskipun kedua layanan MySQL dan Nginx akan berdasarkan citra asali yang diperoleh dari Docker Hub, kita tetap perlu membangun citra khusus untuk kontainer aplikasi. Kita akan menciptakan Dockerfile yang baru untuk itu.

Citra travellist kita akan berdasarkan citra PHP resmi php:7.4-fpm dari Docker Hub. Selain lingkungan PHP-FPM dasar tersebut, kita akan menginstal beberapa modul PHP tambahan dan alat manajemen dependensi Composer.

Kita juga akan menciptakan pengguna sistem baru; ini diperlukan untuk mengeksekusi perintah artisan dan composer ketika mengembangkan aplikasi. Pengaturan uid memastikan bahwa pengguna di dalam kontainer memiliki uid yang sama seperti pengguna sistem di mesin hos, tempat Anda menjalankan Docker. Dengan cara ini, berkas apa pun yang diciptakan oleh perintah-perintah ini direplikasi di dalam hos dengan izin yang benar. Ini juga berarti Anda dapat menggunakan editor kode pilihan Anda di mesin hos untuk mengembangkan aplikasi yang berjalan di dalam kontainer.

Buat Dockerfile yang baru dengan:

nano Dockerfile

Salin konten berikut ke Dockerfile Anda:

FROM php:7.4-fpm

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

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

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

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

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

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

# Set working directory
WORKDIR /var/www

USER $user

Jangan lupa simpan berkas itu saat Anda selesai.

Dockerfile dimulai dengan menentukan citra dasar yang kita gunakan: php:7.4-fpm.

Setelah menginstal paket sistem dan ekstensi PHP, kita menginstal Composer dengan menyalin perintah composer yang dapat dieksekusi dari citra resmi terbarunya ke citra aplikasi kita.

Pengguna sistem baru kemudian diciptakan dan disiapkan dengan menggunakan argumen user dan uid yang dinyatakan di awal Dockerfile. Nilai-nilai ini akan dimasukkan oleh Docker Compose saat pembangunan.

Terakhir, kita mengatur dir kerja asali sebagai /var/www dan mengganti ke pengguna yang baru diciptakan. Ini akan memastikan Anda terhubung sebagai pengguna reguler, dan berada di direktori yang tepat, saat menjalankan perintah composer dan artisan di kontainer aplikasi.

Langkah 4 — Menyiapkan Konfigurasi Nginx dan Berkas Buangan Basis Data

Ketika menciptakan lingkungan pengembangan dengan Docker Compose, seringkali diperlukan untuk berbagi berkas konfigurasi atau inisialisasi dengan kontainer layanan, yang bertujuan menyiapkan atau melakukan bootstrap terhadap layanan tersebut. Praktik ini memfasilitasi pembuatan perubahan terhadap berkas konfigurasi untuk menyetel lingkungan saat Anda mengembangkan aplikasi.

Sekarang kita akan menyiapkan folder dengan berkas yang akan digunakan untuk mengonfigurasi dan menginisialisasi kontainer layanan.

Untuk menyiapkan Nginx, kita akan berbagi berkas travellist.conf yang akan mengonfigurasi cara penyajian aplikasi. Buat folder docker-compose/nginx dengan:

mkdir -p docker-compose/nginx

Buka berkas baru yang bernama travellist.conf di dalam direktori itu:

nano docker-compose/nginx/travellist.conf

Salin konfigurasi Nginx berikut ke berkas itu:

server {
    listen 80;
    index index.php index.html;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
    location / {
        try_files $uri $uri/ /index.php?$query_string;
        gzip_static on;
    }
}

Berkas ini akan mengonfigurasi Nginx untuk mendengarkan porta 80 dan menggunakan index.php sebagai laman indeks asali. Ini akan menetapkan root dokumen menjadi /var/www/public, lalu mengonfigurasi Nginx untuk menggunakan layanan app pada porta 9000 yang memproses berkas *.php.

Simpan dan tutup berkas setelah Anda selesai mengedit.

Untuk menyiapkan basis data MySQL, kita akan berbagi buangan basis data yang akan diimpor saat kontainer diinisialisasi. Ini adalah fitur yang yang disediakan oleh citra MySQL 5.7 yang akan kita gunakan pada kontainer itu.

Buat folder baru untuk berkas inisialisasi MySQL Anda di dalam folder docker-compose:

mkdir docker-compose/mysql

Buka berkas .sql yang baru:

nano docker-compose/mysql/init_db.sql

Buangan MySQL berikut ini berdasarkan basis data yang telah kita siapkan dalam panduan Laravel pada LEMP dari kami. Ini akan menciptakan tabel baru yang bernama places. Lalu, tabel akan terisi dengan serangkaian tempat sampel.

Tambahkan kode berikut ke berkas:

DROP TABLE IF EXISTS `places`;

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

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

Tabel places berisi tiga bidang: id, name, dan visited. Bidang visited adalah bendera yang digunakan untuk mengidentifikasi tempat-tempat yang masih harus* dikunjungi*. Silakan ganti tempat sampel atau masukkan tempat yang baru. Simpan dan tutup berkas setelah Anda selesai.

Kita telah selesai menyiapkan Dockerfile aplikasi dan berkas konfigurasi layanan. Selanjutnya, kita akan menyiapkan Docker Compose untuk menggunakan berkas-berkas ini saat menciptakan layanan kita.

Langkah 5 — Menciptakan Lingkungan Multi-Kontainer dengan Docker Compose

Docker Compose memungkinkan Anda menciptakan lingkungan multi-kontainer untuk aplikasi yang berjalan pada Docker. Ini menggunakan definisi layanan untuk sepenuhnya membangun lingkungan yang dapat disesuaikan dengan beberapa kontainer yang dapat berbagi volume data dan jaringan. Ini memungkinkan integrasi tanpa hambatan di antara komponen aplikasi.

Untuk menyiapkan definisi layanan, kita akan menciptakan berkas baru yang bernama docker-compose.yml. Biasanya, berkas ini berada di root dari folder aplikasi, dan mendefinisikan lingkungan terkontainerisasi, termasuk citra dasar yang Anda gunakan untuk membangun kontainer, dan bagaimana layanan Anda berinteraksi.

Kita akan mendefinisikan tiga layanan berbeda dalam berkas docker-compose.yml: app, db, dan nginx.

Layanan app akan membangun citra yang disebut travellist, berdasarkan Dockerfile yang kita ciptakan sebelumnya. Kontainer yang didefinisikan oleh layanan ini akan menjalankan server php-fpm untuk mengurai kode PHP dan mengirim hasilnya kembali ke layanan nginx, yang akan berjalan pada kontainer terpisah. Layanan mysql mendefinisikan kontainer yang menjalankan server MySQL 5.7. Layanan kita akan berbagi jaringan jembatan bernama travellist.

Berkas aplikasi akan disinkronkan baik pada layanan app dan nginx melalui bind mounts. Bind mounts berguna dalam lingkungan pengembangan karena mengizinkan sinkronisasi dua arah dengan performa yang baik antara mesin hos dan kontainer.

Buat berkas docker-compose.yml baru di root dari folder aplikasi:

nano docker-compose.yml

Berkas docker-compose.yml khusus dimulai dengan definisi versi, diikuti oleh node services, yang mendefinisikan semua layanan. Jaringan bersama biasanya didefinisikan di bagian bawah berkas itu.

Untuk memulai, salin kode boilerplate ini ke berkas docker-compose.yml:

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Sekarang kita akan mengedit node services untuk menyertakan layanan app, db, dan nginx.

Layanan app

Layanan app akan menyiapkan kontainer bernama travellist-app. Ini membangun citra Docker baru berdasarkan Dockerfile yang terletak di jalur yang sama seperti berkas docker-compose.yml. Citra baru akan disimpan secara lokal dengan nama travellist.

Meskipun root dokumen yang disajikan sebagai aplikasi berada di dalam kontainer nginx, kita juga memerlukan berkas aplikasi di suatu tempat di dalam kontainer app, sehingga kita dapat melaksanakan tugas baris perintah dengan alat Laravel Artisan.

Salin definisi layanan berikut di bawah node services, di dalam berkas docker-compose.yml:

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

Pengaturan ini melakukan yang berikut:

• build: Konfigurasi ini memberi tahu Docker Compose untuk membangun citra lokal layanan app, menggunakan jalur yang ditentukan (context) dan Dockerfile untuk instruksi. Argumen user dan uid dimasukkan ke Dockerfile untuk menyesuaikan perintah penciptaan pengguna saat pembangunan.
• image: Nama yang akan digunakan untuk citra yang sedang dibangun.
• container_name: Menyiapkan nama kontainer untuk layanan ini.
• restart: Selalu mulai ulang, kecuali layanan dihentikan.
• working_dir: Menetapkan direktori asali untuk layanan ini sebagai /var/www.
• volumes: Menciptakan volume bersama yang akan menyinkronkan konten dari direktori saat ini dengan /var/www di dalam kontainer. Perhatikan bahwa ini bukan root dokumen Anda, karena itu akan hidup di dalam kontainer nginx.
• networks: Menyiapkan layanan ini untuk menggunakan jaringan yang bernama travellist.

Layanan db

Layanan db menggunakan citra MySQL 5.7 yang telah disiapkan sebelumnya dari Docker Hub. Karena Docker Compose secara otomatis memuat berkas variabel .env yang terletak di dalam direktori yang sama dengan berkas docker-compose.yml, kita dapat memperoleh pengaturan basis data dari berkas .env Laravel yang kita ciptakan dalam langkah sebelumnya.

Sertakan definisi layanan berikut di node services Anda, tepat setelah layanan app:

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

Pengaturan ini melakukan yang berikut:

• image: Menetapkan citra Docker yang harus digunakan untuk kontainer ini. Dalam kasus ini, kita menggunakan citra MySQL 5.7 dari Docker Hub.
• container_name: Menyiapkan nama kontainer untuk layanan ini: travellist-db.
• restart: Selalu mulai ulang layanan ini, kecuali jika layanan secara eksplisit dihentikan.
• environment: Menetapkan variabel lingkungan di dalam kontainer baru. Kita menggunakan nilai yang diperoleh dari berkas .env Laravel untuk menyiapkan layanan MySQL, yang secara otomatis akan menciptakan pengguna dan basis data baru berdasarkan variabel lingkungan yang disediakan.
• volumes: Menciptakan volume untuk berbagi buangan basis data .sql yang akan digunakan untuk menginisialisasi basis data aplikasi. Citra MySQL akan secara otomatis mengimpor berkas .sql yang ditempatkan di direktori /docker-entrypoint-initdb.d di dalam kontainer.
• networks: Menyiapkan layanan ini untuk menggunakan jaringan yang bernama travellist.

Layanan nginx

Layanan nginx menggunakan citra Nginx yang telah disiapkan sebelumnya di atas Alpine, distribusi Linux yang ringan. Ini menciptakan kontainer bernama travellist-nginx, dan menggunakan definisi ports untuk menciptakan pengarahan ulang dari porta 8000 pada sistem hos ke porta 80 di dalam kontainer.

Sertakan definisi layanan berikut di node services, tepat setelah layanan db:

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

Pengaturan ini melakukan yang berikut:

• image: Menetapkan citra Docker yang harus digunakan untuk kontainer ini. Dalam kasus ini, kita menggunakan citra Alpine Nginx 1.17.
• container_name: Menyiapkan nama kontainer untuk layanan ini: travellist-nginx.
• restart: Selalu mulai ulang layanan ini, kecuali jika layanan secara eksplisit dihentikan.
• ports: Menyiapkan pengarahan ulang porta yang akan mengizinkan akses eksternal melalui porta 8000 ke server web yang berjalan di porta 80 di dalam kontainer.
• volumes: Menciptakan dua volume bersama. Yang pertama akan melakukan sinkronisasi konten dari direktori saat ini dengan /var/www di dalam kontainer. Dengan cara ini, saat Anda melakukan perubahan lokal pada berkas aplikasi, itu akan segera tercermin dengan cepat di aplikasi yang disajikan oleh Nginx di dalam kontainer. Volume kedua akan memastikan berkas konfigurasi Nginx, yang terletak di docker-compose/nginx/travellist.conf, disalin ke folder konfigurasi Nginx di dalam kontainer.
• networks: Menyiapkan layanan ini untuk menggunakan jaringan bernama travellist.

Berkas docker-compose.yml yang Sudah Selesai

Berkas docker-compose.yml yang sudah selesai akan terlihat seperti ini:

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

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

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

networks:
  travellist:
    driver: bridge

Pastikan menyimpan berkas itu saat Anda selesai.

Langkah 6 — Menjalankan Aplikasi dengan Docker Compose

Sekarang kita akan menggunakan perintah docker-compose untuk membangun citra aplikasi dan menjalankan layanan yang kita tetapkan dalam penyiapan.

Bangun citra app dengan perintah berikut:

docker-compose build app

Perintah ini mungkin membutuhkan waktu beberapa menit untuk selesai. Anda akan melihat keluaran yang serupa dengan ini:

Output
Building app
Step 1/11 : FROM php:7.4-fpm
 ---> fa37bd6db22a
Step 2/11 : ARG user
 ---> Running in f71eb33b7459
Removing intermediate container f71eb33b7459
 ---> 533c30216f34
Step 3/11 : ARG uid
 ---> Running in 60d2d2a84cda
Removing intermediate container 60d2d2a84cda
 ---> 497fbf904605
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     ...
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> e499f74896e3
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> Running in 232ef9c7dbd1
Removing intermediate container 232ef9c7dbd1
 ---> 870fa3220ffa
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> Running in 7ca8c0cb7f09
Removing intermediate container 7ca8c0cb7f09
 ---> 3d2ef9519a8e
Step 10/11 : WORKDIR /var/www
 ---> Running in 4a964f91edfa
Removing intermediate container 4a964f91edfa
 ---> 00ada639da21
Step 11/11 : USER $user
 ---> Running in 9f8e874fede9
Removing intermediate container 9f8e874fede9
 ---> fe176ff4702b

Successfully built fe176ff4702b
Successfully tagged travellist:latest

Ketika proses pembangunan selesai, Anda dapat menjalankan lingkungan dalam mode latar belakang dengan:

docker-compose up -d

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

Ini akan menjalankan kontainer Anda di latar belakang. Untuk menunjukkan informasi tentang kondisi layanan aktif, jalankan:

docker-compose ps

Anda akan melihat keluaran seperti ini:

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

Lingkungan Anda kini sudah aktif dan berjalan, tetapi kita masih perlu mengeksekusi beberapa perintah untuk menyelesaikan pengaturan aplikasi. Anda dapat menggunakan perintah docker-compose exec untuk mengeksekusi perintah di dalam kontainer layanan, seperti ls -l untuk menampilkan informasi detail tentang berkas di dalam direktori aplikasi:

docker-compose exec app ls -l

Output
total 260
-rw-rw-r--  1 sammy sammy    737 Jun  9 11:19 Dockerfile
-rw-rw-r--  1 sammy sammy    101 Jan  7 08:05 README.md
drwxrwxr-x  6 sammy sammy   4096 Jan  7 08:05 app
-rwxr-xr-x  1 sammy sammy   1686 Jan  7 08:05 artisan
drwxrwxr-x  3 sammy sammy   4096 Jan  7 08:05 bootstrap
-rw-rw-r--  1 sammy sammy   1501 Jan  7 08:05 composer.json
-rw-rw-r--  1 sammy sammy 179071 Jan  7 08:05 composer.lock
drwxrwxr-x  2 sammy sammy   4096 Jan  7 08:05 config
drwxrwxr-x  5 sammy sammy   4096 Jan  7 08:05 database
drwxrwxr-x  4 sammy sammy   4096 Jun  9 11:19 docker-compose
-rw-rw-r--  1 sammy sammy    965 Jun  9 11:27 docker-compose.yml
-rw-rw-r--  1 sammy sammy   1013 Jan  7 08:05 package.json
-rw-rw-r--  1 sammy sammy   1405 Jan  7 08:05 phpunit.xml
drwxrwxr-x  2 sammy sammy   4096 Jan  7 08:05 public
-rw-rw-r--  1 sammy sammy    273 Jan  7 08:05 readme.md
drwxrwxr-x  6 sammy sammy   4096 Jan  7 08:05 resources
drwxrwxr-x  2 sammy sammy   4096 Jan  7 08:05 routes
-rw-rw-r--  1 sammy sammy    563 Jan  7 08:05 server.php
drwxrwxr-x  5 sammy sammy   4096 Jan  7 08:05 storage
drwxrwxr-x  4 sammy sammy   4096 Jan  7 08:05 tests
drwxrwxr-x 41 sammy sammy   4096 Jun  9 11:32 vendor
-rw-rw-r--  1 sammy sammy    538 Jan  7 08:05 webpack.mix.js

Sekarang kita akan menjalankan composer install untuk menginstal dependensi aplikasi:

docker-compose exec app composer install

Anda akan melihat keluaran seperti ini:

Output
Loading composer repositories with package information
Installing dependencies (including require-dev) from lock file
Package operations: 85 installs, 0 updates, 0 removals
  - Installing doctrine/inflector (1.3.1): Downloading (100%)         
  - Installing doctrine/lexer (1.2.0): Downloading (100%)         
  - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%)         
  - Installing erusev/parsedown (1.7.4): Downloading (100%)         
  - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%)         
  - Installing phpoption/phpoption (1.7.2): Downloading (100%)         
  - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%)         
  - Installing symfony/css-selector (v5.0.2): Downloading (100%)             
…
Generating optimized autoload files
> Illuminate\Foundation\ComposerScripts::postAutoloadDump
> @php artisan package:discover --ansi
Discovered Package: facade/ignition
Discovered Package: fideloper/proxy
Discovered Package: laravel/tinker
Discovered Package: nesbot/carbon
Discovered Package: nunomaduro/collision
Package manifest generated successfully.

Hal terakhir yang perlu kita lakukan sebelum menguji aplikasi ini adalah menghasilkan kunci aplikasi unik dengan alat baris perintah Laravel artisan. Kunci ini digunakan untuk mengenkripsi sesi pengguna dan data sensitif lainnya:

docker-compose exec app php artisan key:generate

Output
Application key set successfully.

Sekarang, buka peramban Anda dan akses nama domain server atau alamat IP Anda pada porta 8000:

http://server_domain_or_IP:8000

Anda akan melihat sebuah laman seperti ini:

Anda dapat menggunakan perintah logs untuk memeriksa log yang dihasilkan oleh layanan Anda:

docker-compose logs nginx

Attaching to travellist-nginx
…
travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up
travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"

Jika Anda ingin menghentikan sementara lingkungan Docker Compose sembari tetap mempertahankan kondisi semua layanan, jalankan:

docker-compose pause

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

Kemudian, Anda dapat melanjutkan layanan dengan:

docker-compose unpause

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

Untuk mematikan lingkungan Docker Compose dan menghapus semua kontainer, jaringan, dan volumenya, jalankan:

docker-compose down

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

Untuk ikhtisar dari semua perintah Docker Compose, lihat referensi baris perintah Docker Compose.

Kesimpulan

Dalam panduan ini, kita telah menyiapkan lingkungan Docker dengan tiga kontainer yang menggunakan Docker Compose untuk mendefinisikan infrastruktur dalam berkas YAML.

Mulai dari sekarang, Anda dapat bekerja di aplikasi Laravel tanpa perlu menginstal dan menyiapkan server web lokal untuk pengembangan dan pengujian. Lebih jauh lagi, Anda akan bekerja dengan lingkungan yang dapat dibuang serta mudah direplikasi dan didistribusikan, yang dapat membantu saat mengembangkan aplikasi Anda dan menjelang pembuatan suatu lingkungan.