One place for hosting & domains

      Menyiapkan

      Cara Menyiapkan Proyek Node dengan Typescript


      Pengantar

      Node adalah lingkungan run-time yang memungkinkan penulisan JavaScript di pihak server. Ini telah banyak digunakan sejak dirilis tahun 2011. Menulis JavaScript di pihak server dapat menjadi hal yang menantang seiring berkembangnya basis kode karena sifat bahasa JavaScript; dinamis dan bertipe lemah.

      Para pengembang yang memilih JavaScript dari bahasa lain sering mengeluhkan kekurangan tipe statis kuat, di sinilah TypeScript hadir menjembatani kesenjangan itu.

      TypeScript adalah super-set bertipe (opsional) dari JavaScript yang dapat membantu membangun dan mengelola proyek JavaScript berskala besar. Ini dapat dianggap sebagai JavaScript dengan fitur tambahan, seperti tipe statis kuat, kompilasi, dan pemrograman berorientasi objek.

      Catatan: TypeScript secara teknis adalah super-set JavaScript, yang berarti semua kode JavaScript adalah kode TypeScript yang valid.

      Berikut ini beberapa manfaat menggunakan TypeScript:

      1. Tipe statis opsional.
      2. Tipe interferensi.
      3. Kemampuan untuk menggunakan Antarmuka.

      Dalam tutorial ini, Anda akan menyiapkan proyek Node dengan TypeScript. Anda akan membangun aplikasi Express menggunakan TypeScript dan menerjemahkannya menjadi kode JavaScript yang rapi dan andal.

      Prasyarat

      Sebelum memulai panduan ini, Node.js sudah harus terinstal di mesin Anda. Anda dapat melakukannya dengan mengikuti panduan Cara Menginstal Node.js dan Membuat Lingkungan Pengembangan Lokal bagi sistem operasi Anda.

      Langkah 1 — Inisialisasi Proyek npm

      Untuk memulai, buat folder baru bernama node_project dan pindah ke direktori itu.

      • mkdir node_project
      • cd node_project

      Selanjutnya, inisialisasi sebagai proyek npm:

      Setelah menjalankan init npm, Anda perlu memberikan informasi tentang proyek Anda kepada npm. Jika Anda lebih suka membiarkan npm mengasumsikan asali yang wajar, Anda dapat menambahkan bendera y untuk melewatkan prompt informasi tambahan:

      Karena kini ruang proyek sudah disiapkan, Anda siap untuk melanjutkan ke instalasi dependensi yang diperlukan.

      Langkah 2 — Menginstal Dependensi

      Dengan proyek npm kosong yang telah diinisialisasi, langkah selanjutnya adalah menginstal dependensi yang diperlukan untuk menjalankan TypeScript.

      Jalankan perintah berikut dari direktori proyek Anda untuk menginstal dependensi:

      • npm install -D typescript@3.3.3
      • npm install -D tslint@5.12.1

      Bendera -D adalah pintasan untuk: --save-dev. Anda dapat mempelajari lebih lanjut tentang bendera ini dalam dokumentasi npmjs.

      Sekarang, saatnya menginstal kerangka kerja Express:

      • npm install -S express@4.16.4
      • npm install -D @types/express@4.16.1

      Perintah kedua menginstal beberapa tipe Express untuk dukungan TypeScript. Tipe dalam TypeScript adalah berkas, biasanya dengan ekstensi .d.ts. Berkas digunakan untuk memberikan informasi tentang API kepada tipe, dalam hal ini adalah kerangka kerja Express.

      Paket ini diperlukan karena TypeScript dan Express adalah paket independen. Tanpa paket @types/express, TypeScript tidak dapat mengetahui tipe kelas Express.

      Langkah 3 — Mengonfigurasi TypeScript

      Di bagian ini, Anda akan menyiapkan TypeScript dan mengonfigurasi proses lint untuk TypeScript. TypeScript menggunakan berkas bernama tsconfig.json untuk mengonfigurasi opsi pengompilasi proyek. Buat berkas tsconfig.json di root direktori proyek dan tempelkan dalam cuplikan kode berikut:

      tsconfig.json

      {
        "compilerOptions": {
          "module": "commonjs",
          "esModuleInterop": true,
          "target": "es6",
          "moduleResolution": "node",
          "sourceMap": true,
          "outDir": "dist"
        },
        "lib": ["es2015"]
      }
      

      Mari kita tinjau beberapa hal pokok dalam cuplikan JSON di atas:

      • module: Menentukan metode pembuatan kode modul. Node menggunakan commonjs.
      • target: Menentukan tingkat bahasa keluaran.
      • moduleResolution: Ini membantu pengompilasi mengetahui apa yang dirujuk oleh impor. Nilai node menirukan mekanisme resolusi modul Node.
      • outDir: Ini adalah lokasi untuk keluaran berkas .js setelah penerjemahan. Dalam tutorial ini, Anda akan menyimpannya sebagai dist.

      Alternatif untuk membuat dan mengisi berkas tsconfig.json adalah dengan menjalankan perintah berikut:

      Perintah ini akan menghasilkan berkas tsconfig.json yang telah diberi komentar dengan baik.

      Untuk mempelajari lebih lanjut berbagai opsi nilai kunci yang tersedia, dokumentasi TypeScript resmi memberikan penjelasan tentang setiap opsi.

      Sekarang Anda dapat mengonfigurasi proses lint TypeScript untuk proyek. Dalam terminal yang sedang berjalan di root direktori proyek Anda, tempat tutorial ini dibuat sebagai node_project, jalankan perintah berikut untuk menghasilkan berkas tslint.json:

      • ./node_modules/.bin/tslint --init

      Buka berkas tslint.json yang baru dihasilkan dan tambahkan aturan no-console yang sesuai:

      tslint.json

      {
        "defaultSeverity": "error",
        "extends": ["tslint:recommended"],
        "jsRules": {},
        "rules": {
          "no-console": false
        },
        "rulesDirectory": []
      }
      

      Secara asali, linter di TypeScript mencegah penggunaan awakutu dengan pernyataan console, sehingga perlu secara eksplisit memberi tahu linter untuk mencabut aturan no-console asali.

      Langkah 4 — Memperbarui Berkas package.json

      Pada titik ini dalam tutorial, Anda dapat menjalankan fungsi dalam terminal satu per satu, atau membuat npm script untuk menjalankannya.

      Dalam langkah ini, Anda akan membuat skrip start yang akan mengompilasi dan menerjemahkan kode TypeScript, kemudian menjalankan app.js yang dihasilkan.

      Buka berkas package.json dan perbarui sebagaimana mestinya:

      package.json

      {
        "name": "node-with-ts",
        "version": "1.0.0",
        "description": "",
        "main": "dist/app.js",
        "scripts": {
          "start": "tsc && node dist/app.js",
          "test": "echo "Error: no test specified" && exit 1"
        },
        "author": "",
        "license": "ISC",
        "devDependencies": {
          "@types/express": "^4.16.1",
          "tslint": "^5.12.1",
          "typescript": "^3.3.3"
        },
        "dependencies": {
          "express": "^4.16.4"
        }
      }
      

      Dalam cuplikan di atas, Anda memperbarui jalur main dan menambahkan perintah start ke bagian skrip. Bila memperhatikan perintah start, Anda akan melihat bahwa perintah tsc pertama adalah berjalan, kemudian perintah node. Ini akan mengompilasi kemudian menjalankan keluaran yang dihasilkan dengan node.

      Perintah tsc memberi tahu TypeScript untuk mengompilasi aplikasi dan menempatkan keluaran .js yang dihasilkan dalam direktori outDir yang ditentukan karena telah diatur dalam berkas tsconfig.json.

      Langkah 5 — Membuat dan Menjalankan Server Express Dasar

      Karena TypeScript dan linter telah dikonfigurasi, saatnya membangun Server Express Node.

      Pertama-tama, buat folder src di root direktori proyek Anda:

      Kemudian, buat berkas bernama app.ts di dalamnya:

      Sehingga struktur folder akan terlihat seperti ini:

      ├── node_modules/
      ├── src/
        ├── app.ts
      ├── package-lock.json
      ├── package.json
      ├── tsconfig.json
      ├── tslint.json
      

      Buka berkas app.ts dengan editor teks pilihan Anda dan tempelkan dalam cuplikan kode berikut:

      src/app.ts

      import express from 'express';
      
      const app = express();
      const port = 3000;
      app.get('/', (req, res) => {
        res.send('The sedulous hyena ate the antelope!');
      });
      app.listen(port, err => {
        if (err) {
          return console.error(err);
        }
        return console.log(`server is listening on ${port}`);
      });
      

      Kode di atas membuat Server Node yang mendengarkan permintaan di porta 3000. Jalankan aplikasi menggunakan perintah berikut:

      Jika berhasil dijalankan, pesan akan dicatat ke terminal:

      Output

      • server is listening on 3000

      Sekarang, Anda dapat mengunjungi http://localhost:3000 di peramban Anda dan seharusnya melihat pesan:

      Output

      • The sedulous hyena ate the antelope!

      Jendela peramban berisi pesan: The sedulous hyena ate the antelope!

      Buka berkas dist/app.js dan Anda akan menemukan versi kode TypeScript yang telah diterjemahkan:

      dist/app.js

      "use strict";
      
      var __importDefault = (this && this.__importDefault) || function (mod) {
          return (mod && mod.__esModule) ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      const express_1 = __importDefault(require("express"));
      const app = express_1.default();
      const port = 3000;
      app.get('/', (req, res) => {
          res.send('The sedulous hyena ate the antelope!');
      });
      app.listen(port, err => {
          if (err) {
              return console.error(err);
          }
          return console.log(`server is listening on ${port}`);
      });
      
      //# sourceMappingURL=app.js.map
      

      Saat ini, Anda berhasil menyiapkan proyek Node menggunakan TypeScript.

      Kesimpulan

      Dalam tutorial ini, Anda telah mempelajari alasan TypeScript berguna untuk penulisan kode JavaScript yang andal. Anda juga telah mempelajari beberapa manfaat menggunakan TypeScript.

      Terakhir, Anda telah menyiapkan proyek Node dengan kerangka kerja Express, kemudian mengompilasi dan menjalankan proyek dengan TypeScript.



      Source link

      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

      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:

      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.

      Peringatan: Berkas konfigurasi lingkungan berisi informasi sensitif tentang server Anda, termasuk kredensial basis data dan kunci keamanan. Dengan alasan itu, Anda jangan pernah membagikan berkas ini secara publik.

      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:

      Buka berkas ini menggunakan nano atau editor teks pilihan Anda:

      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:

      .env

      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:

      Salin konten berikut ke Dockerfile Anda:

      Dockerfile

      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:

      docker-compose/nginx/travellist.conf

      
      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:

      docker-compose/mysql/db_init.sql

      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:

      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:

      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:

      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:

      docker-compose.yml

        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:

      docker-compose.yml

        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:

      docker-compose.yml

      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:

      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:

      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:

      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 > IlluminateFoundationComposerScripts::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
      

      Catatan: Jika Anda menjalankan demo ini pada mesin lokal, gunakan http://localhost:8000 untuk mengakses aplikasi dari peramban Anda.

      Anda akan melihat sebuah laman seperti ini:

      Aplikasi Laravel Demo

      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:

      Output

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

      Kemudian, Anda dapat melanjutkan layanan dengan:

      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:

      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.



      Source link

      Cara Menyiapkan Mount NFS di Ubuntu 20.04


      Pengantar

      NFS, atau Sistem Berkas Jaringan, adalah protokol sistem berkas terdistribusi yang memungkinkan Anda untuk melakukan mount direktori jauh di server Anda. Ini memungkinkan Anda mengelola ruang penyimpanan di lokasi berbeda dan menulis ke ruang itu dari beberapa klien. NFS menyediakan cara yang relatif standar dan efektif untuk mengakses sistem jauh melalui jaringan dan berfungsi dengan baik ketika harus mengakses sumber daya bersama secara rutin.

      Dalam panduan ini, kita akan membahas cara menginstal perangkat lunak yang dibutuhkan untuk fungsionalitas NFS di Ubuntu 20.04, mengonfigurasi dua mount NFS di server dan klien, serta cara melakukan mount dan unmount direktori jauh bersama.

      Prasyarat

      Kita akan menggunakan dua server dalam tutorial ini, dengan satu bagian sistem berkas yang digunakan bersama. Untuk mengikuti, Anda akan membutuhkan:

      • Dua server Ubuntu 20.04. Masing-masing server ini harus memiliki pengguna non-root dengan privilese sudo, firewall yang disiapkan dengan UFW, dan jaringan privat, jika tersedia.

        • Untuk menyiapkan pengguna non-root dengan privilese sudo dan firewall, ikuti panduan Penyiapan Server Awal dengan Ubuntu 20.04 dari kami.
        • Jika Anda menggunakan DigitalOcean Droplets untuk server dan klien, Anda dapat membaca lebih lanjut tentang menyiapkan jaringan privat dalam dokumentasi kami mengenai Cara Membuat VPC.

      Sepanjang tutorial ini, kita merujuk ke server yang berbagi direktori sebagai hos dan server yang melakukan mount direktori ini sebagai klien. Anda perlu mengetahui alamat IP keduanya. Pastikan menggunakan alamat jaringan privat, jika tersedia.

      Sepanjang tutorial, kita akan merujuk ke alamat IP ini dengan tempat teks host_ip dan client_ip. Gantilah bila perlu.

      Langkah 1 — Mengunduh dan Menginstal Komponen

      Kita akan mulai dengan menginstal komponen yang diperlukan di setiap server.

      Di Hos

      Di server hos, instal paket nfs-kernel-server, yang akan memungkinkan Anda berbagi direktori. Karena ini adalah operasi pertama yang Anda lakukan dengan apt di sesi ini, perbarui indeks paket lokal Anda sebelum instalasi:

      • sudo apt update
      • sudo apt install nfs-kernel-server

      Setelah paket-paket ini diinstal, beralihlah ke server klien.

      Di Klien

      Di server klien, kita perlu menginstal paket bernama nfs-common yang menyediakan fungsionalitas NFS tanpa menyertakan komponen server apa pun. Sekali lagi, perbarui indeks paket lokal sebelum instalasi untuk memastikan Anda memiliki informasi terbaru:

      • sudo apt update
      • sudo apt install nfs-common

      Karena kedua server memiliki paket yang diperlukan, kita dapat mulai mengonfigurasinya.

      Langkah 2 — Membuat Direktori Bersama di Hos

      Kita akan berbagi dua direktori terpisah, dengan pengaturan konfigurasi yang berbeda, untuk menggambarkan dua cara utama mengonfigurasi mount NFS berkenaan dengan akses superuser.

      Superuser dapat melakukan apa saja di sistem mereka. Walau demikian, direktori yang melakukan mount NFS bukanlah bagian dari sistem tempat direktori itu di-mount, jadi secara asali, server NFS menolak melakukan operasi yang membutuhkan privilese superuser. Pembatasan asali ini berarti superuser di klien tidak dapat menulis berkas sebagai root, menetapkan ulang kepemilikan, atau melakukan tugas superuser lainnya pada mount NFS.

      Walau demikian, terkadang ada pengguna tepercaya di sistem klien yang perlu melakukan tindakan-tindakan ini di sistem berkas yang melakukan mount tetapi tidak perlu memiliki akses superuser di hos. Anda dapat mengonfigurasi server NFS untuk mengizinkan hal ini, walaupun menimbulkan unsur risiko, karena pengguna tersebut _dapat _memperoleh akses root ke seluruh sistem hos.

      Contoh 1: Mengekspor Mount Serbaguna

      Dalam contoh pertama, kita akan membuat mount NFS serbaguna yang menggunakan perilaku NFS asali untuk mempersulit pengguna dengan privilese root di mesin klien dalam berinteraksi dengan hos menggunakan privilese superuser klien tersebut. Anda dapat menggunakan sesuatu seperti ini untuk menyimpan berkas yang diunggah menggunakan sistem manajemen konten atau membuat ruang bagi pengguna agar mudah berbagi berkas proyek.

      Pertama-tama, buat direktori bersama:

      • sudo mkdir /var/nfs/general -p

      Karena kita membuatnya dengan sudo, direktori dimiliki oleh pengguna root hos:

      Output

      drwxr-xr-x 2 root root 4096 May 14 18:36 .

      NFS akan menerjemahkan operasi root apa pun di klien ke kredensial nobody:nogroup sebagai tindakan keamanan. Karenanya, kita perlu mengubah kepemilikan direktori agar sesuai dengan kredensial itu.

      • sudo chown nobody:nogroup /var/nfs/general

      Sekarang Anda siap mengekspor direktori ini.

      Contoh 2: Mengekspor Direktori Rumah

      Dalam contoh kedua, tujuannya adalah membuat direktori rumah pengguna yang disimpan di hos tersedia di server klien, sekaligus memberikan akses yang dibutuhkan administrator tepercaya dari server klien tersebut untuk mengelola pengguna dengan mudah.

      Untuk melakukannya, kita akan mengekspor direktori /home. Karena sudah ada, kita tidak perlu membuatnya. Kita juga tidak akan mengubah izinnya. Jika dilakukan, ini dapat menyebabkan serangkaian masalah bagi siapa saja yang memiliki direktori rumah di mesin hos tersebut.

      Langkah 3 — Mengonfigurasi Ekspor NFS di Server Hos

      Selanjutnya, kita akan masuk ke dalam berkas konfigurasi NFS untuk persiapan berbagi sumber daya ini.

      Di mesin hos, buka berkas /etc/export dalam editor teks Anda dengan privilese root:

      Berkas itu memiliki komentar yang menunjukkan struktur umum setiap baris konfigurasi. Sintaksnya adalah sebagai berikut:

      /etc/exports

      directory_to_share    client(share_option1,...,share_optionN)
      

      Kita perlu membuat sebuah baris untuk setiap direktori yang rencananya akan kita gunakan bersama. Pastikan mengubah tempat teks client_ip yang ditunjukkan di sini ke alamat IP Anda yang sebenarnya:

      /etc/exports

      /var/nfs/general    client_ip(rw,sync,no_subtree_check)
      /home               client_ip(rw,sync,no_root_squash,no_subtree_check)
      

      Di sini, kita menggunakan opsi konfigurasi yang sama untuk kedua direktori dengan pengecualian no_root_squash. Mari kita lihat arti setiap opsi ini:

      • rw: Opsi ini memberi komputer klien dengan akses baca dan tulis ke volume.
      • sync: Opsi ini memaksa NFS menulis perubahan ke diska sebelum menjawab. Ini menghasilkan lingkungan yang lebih stabil dan konsisten karena balasan tersebut mencerminkan kondisi aktual dari volume jauh. Namun, hal ini juga mengurangi kecepatan operasi berkas.
      • no_subtree_check: Opsi ini mencegah pemeriksaan subtree, yaitu suatu proses ketika hos harus memeriksa apakah berkas tersebut benar-benar masih tersedia di tree yang diekspor untuk setiap permintaan. Hal ini dapat menyebabkan banyak masalah bila berkas diubah namanya ketika klien telah dibuka. Dalam kebanyakan kasus, lebih baik menonaktifkan pemeriksaan subtree.
      • no_root_squash: Secara asali, NFS menerjemahkan permintaan pengguna root dari jauh menjadi pengguna non-privilese di server. Cara ini dimaksudkan sebagai fitur keamanan untuk mencegah akun root di klien menggunakan sistem berkas hos sebagai root. no_root_squash menonaktifkan perilaku ini untuk direktori bersama tertentu.

      Bila Anda selesai membuat perubahan, simpan dan tutup berkas tersebut. Lalu, untuk membuat direktori bersama dapat digunakan oleh klien yang Anda konfigurasi, mulai ulang server NFS dengan perintah berikut:

      • sudo systemctl restart nfs-kernel-server

      Namun, sebelum Anda dapat menggunakan direktori bersama yang baru, Anda perlu memastikan lalu lintas ke direktori bersama itu diizinkan oleh aturan firewall.

      Langkah 4 — Menyesuaikan Firewall di Hos

      Pertama-tama, mari kita periksa status firewall untuk melihat jika sudah diaktifkan dan, jika sudah, untuk melihat yang diizinkan saat ini:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)

      Di sistem kita, hanya lalu lintas SSH yang boleh melintas, sehingga kita perlu menambahkan aturan untuk lalu lintas NFS.

      Pada banyak aplikasi, Anda dapat menggunakan sudo ufw app list dan mengaktifkannya berdasarkan nama, tetapi nfs tidak termasuk. Namun, karena ufw juga memeriksa /etc/services untuk porta dan protokol layanan, kita masih dapat menambah NFS berdasarkan nama. Praktik terbaik menyarankan Anda untuk mengaktifkan aturan paling ketat yang akan tetap mengizinkan lalu lintas yang Anda inginkan, sehingga daripada mengaktifkan lalu lintas dari mana saja, kita akan lebih spesifik.

      Gunakan perintah berikut untuk membuka porta 2049 di hos, pastikan mengganti alamat IP klien Anda:

      • sudo ufw allow from client_ip to any port nfs

      Anda dapat memverifikasi perubahan dengan mengetik:

      Anda akan melihat lalu lintas yang diizinkan dari porta 2049 dalam keluaran:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 2049 ALLOW 203.0.113.24 OpenSSH (v6) ALLOW Anywhere (v6)

      Ini memastikan bahwa UFW hanya akan mengizinkan lalu lintas NFS di porta 2049 dari mesin klien kita.

      Langkah 5 — Membuat Titik Mount dan Melakukan Mount Direktori di Klien

      Karena kini server hos telah dikonfigurasi dan menyediakan direktori bersamanya, kita akan menyiapkan klien kita.

      Untuk membuat direktori jauh bersama di klien, kita perlu melakukan mount direktori di hos yang ingin dibagikan untuk mengosongkan direktori di klien.

      Catatan: Jika ada berkas dan direktori di titik mount, itu akan disembunyikan begitu Anda melakukan mount direktori bersama NFS. Untuk menghindari kehilangan berkas penting, pastikan direktori itu kosong jika Anda melakukan mount di direktori yang sudah ada.

      Kita akan membuat dua direktori untuk melakukan mount:

      • sudo mkdir -p /nfs/general
      • sudo mkdir -p /nfs/home

      Karena kini kita memiliki lokasi untuk memasukkan direktori jauh bersama dan telah membuka firewall, kita dapat melakukan mount direktori bersama menggunakan alamat IP server hos kita:

      • sudo mount host_ip:/var/nfs/general /nfs/general
      • sudo mount host_ip:/home /nfs/home

      Perintah ini akan melakukan mount direktori bersama dari komputer hos ke mesin klien. Anda dapat memeriksa lagi apakah direktori berhasil melakukan mount dengan beberapa cara. Anda dapat memeriksanya dengan perintah mount atau findmnt, tetapi df -h memberikan keluaran yang lebih mudah dibaca:

      Output

      Filesystem Size Used Avail Use% Mounted on udev 474M 0 474M 0% /dev tmpfs 99M 936K 98M 1% /run /dev/vda1 25G 1.8G 23G 8% / tmpfs 491M 0 491M 0% /dev/shm tmpfs 5.0M 0 5.0M 0% /run/lock tmpfs 491M 0 491M 0% /sys/fs/cgroup /dev/vda15 105M 3.9M 101M 4% /boot/efi tmpfs 99M 0 99M 0% /run/user/1000 10.132.212.247:/var/nfs/general 25G 1.8G 23G 8% /nfs/general 10.132.212.247:/home 25G 1.8G 23G 8% /nfs/home

      Kedua direktori bersama yang kita mount akan muncul di bagian bawah. Karena dilakukan mount dari sistem berkas yang sama, direktori itu akan menunjukkan penggunaan diska yang sama. Untuk melihat seberapa banyak ruang yang sesungguhnya digunakan di setiap titik mount, gunakan perintah penggunaan diska du dan jalur mount. Bendera -s memberikan ringkasan penggunaan, bukan menampilkan penggunaan untuk setiap berkas. -h mencetak keluaran yang mudah dipahami orang.

      Misalnya:

      Output

      36K /nfs/home

      Ini menunjukkan kepada kita seluruh isi direktori rumah hanya menggunakan 36K dari ruang yang tersedia.

      Langkah 6 — Menguji Akses NFS

      Selanjutnya, mari kita uji akses ke direktori bersama dengan menulis sesuatu untuk masing-masing direktori bersama.

      Contoh 1: Direktori Bersama Serbaguna

      Pertama-tama, tulis berkas percobaan ke direktori bersama /var/nfs/general:

      • sudo touch /nfs/general/general.test

      Lalu, periksa kepemilikannya:

      • ls -l /nfs/general/general.test

      Output

      -rw-r--r-- 1 nobody nogroup 0 Aug 1 13:31 /nfs/general/general.test

      Karena kita telah melakukan mount volume ini tanpa mengubah perilaku asali NFS dan membuat berkas sebagai pengguna root mesin klien melalui perintah sudo, kepemilikan berkas asali menjadi nobody:nogroup. Superuser klien tidak akan dapat melakukan tindakan administratif umum, seperti mengubah pemilik berkas atau membuat direktori baru untuk grup pengguna, di direktori bersama yang melakukan mount sebagai NFS.

      Contoh 2: Berbagi Direktori Rumah

      Untuk membandingkan izin direktori bersama Serbaguna dengan Direktori Rumah, buat berkas di /nfs/home dengan cara yang sama:

      • sudo touch /nfs/home/home.test

      Lalu, lihat kepemilikan berkas tersebut:

      • ls -l /nfs/home/home.test

      Output

      -rw-r--r-- 1 root root 0 Aug 1 13:32 /nfs/home/home.test

      Kita telah membuat home.test sebagai root menggunakan perintah sudo, persis sama caranya dengan membuat berkas general.test. Namun, dalam hal ini, berkas ini dimiliki oleh root karena kita mengesampingkan perilaku asali saat menetapkan opsi no_root_squash di mount ini. Hal ini memungkinkan pengguna root kita di mesin klien untuk bertindak sebagai root dan membuat administrasi akun pengguna menjadi jauh lebih mudah. Pada saat bersamaan, ini berarti kita tidak perlu memberi akses root kepada pengguna ini di hos.

      Langkah 7 — Melakukan Mount NFS di Direktori Jauh saat Boot

      Kita dapat melakukan mount NFS di direktori bersama jauh secara otomatis saat boot dengan menambahkannya ke berkas /etc/fstab pada klien.

      Buka berkas ini dengan privilese root di editor teks Anda:

      Di bagian bawah berkas, tambahkan baris untuk masing-masing direktori bersama kita. Hasilnya akan seperti ini:

      /etc/fstab

      . . .
      host_ip:/var/nfs/general    /nfs/general   nfs auto,nofail,noatime,nolock,intr,tcp,actimeo=1800 0 0
      host_ip:/home               /nfs/home      nfs auto,nofail,noatime,nolock,intr,tcp,actimeo=1800 0 0
      
      

      Catatan: Anda dapat menemukan informasi lebih lanjut tentang opsi yang kita tetapkan di sini pada laman utama NFS. Anda dapat mengaksesnya dengan menjalankan perintah berikut:

      Klien akan secara otomatis melakukan mount partisi jauh saat boot, meskipun mungkin perlu beberapa waktu untuk membuat koneksi dan agar direktori bersama tersedia.

      Langkah 8 — Melakukan Unmount NFS di Direktori Bersama Jauh

      Jika tidak ingin direktori jauh melakukan mount di sistem, Anda dapat melakukan unmount dengan mengeluarkan struktur direktori bersama dan melakukan unmount, seperti ini:

      • cd ~
      • sudo umount /nfs/home
      • sudo umount /nfs/general

      Perhatikan bahwa perintah bernama umount tidak melakukan unmount seperti yang Anda harapkan.

      Perintah ini akan menghapus direktori bersama jauh, dengan membiarkan penyimpanan lokal saja yang dapat diakses:

      Output

      Filesystem Size Used Avail Use% Mounted on udev 474M 0 474M 0% /dev tmpfs 99M 936K 98M 1% /run /dev/vda1 25G 1.8G 23G 8% / tmpfs 491M 0 491M 0% /dev/shm tmpfs 5.0M 0 5.0M 0% /run/lock tmpfs 491M 0 491M 0% /sys/fs/cgroup /dev/vda15 105M 3.9M 101M 4% /boot/efi tmpfs 99M 0 99M 0% /run/user/1000

      Jika Anda juga ingin mencegah dilakukan mount kembali saat boot ulang berikutnya, edit /etc/fstab dan hapus baris tersebut atau jadikan komentar dengan menempatkan karakter # di awal baris. Anda juga dapat mencegah mount otomatis dengan menghapus opsi auto, yang akan memungkinkan Anda tetap dapat melakukan mount secara manual.

      Kesimpulan

      Dalam tutorial ini, kita telah membuat hos NFS dan menggambarkan beberapa perilaku utama NFS dengan membuat dua mount NFS berbeda, yang kita gunakan bersama dengan klien NFS.

      Jika Anda ingin menerapkan NFS dalam produksi, perlu diingat bahwa protokolnya tidak dienkripsi. Jika Anda berbagi melalui jaringan privat, mungkin tidak menjadi masalah. Dalam kasus lain, akan diperlukan VPN atau beberapa tipe terowongan terenkripsi untuk melindungi data Anda.



      Source link