One place for hosting & domains

      How to Install WordPress with LEMP on Ubuntu 20.04


      Introduction

      WordPress, one of the most popular content management systems (CMS) on the internet currently, allows users to set up flexible blogs and websites using a MySQL backend with PHP processing. WordPress has seen an incredible adoption rate among new and experienced engineers alike, and is a great choice for getting a website up and running efficiently. After an initial setup, almost all administration for WordPress websites can be done through its graphical interface— these features and more make WordPress a great choice for websites built to scale.

      In this tutorial, you’ll focus on getting an instance of WordPress set up on a LEMP stack (Linux, Nginx, MySQL, and PHP) for an Ubuntu 20.04 server.

      Prerequisites

      In order to complete this tutorial, you’ll need access to an Ubuntu 20.04 server. To successfully install WordPress with LEMP on your server, you’ll also need to perform the following tasks before starting this tutorial:

      • Create a sudo user on your server: The steps in this tutorial are using a non-root user with sudo privileges. You can create a user with sudo privileges by following our Ubuntu 20.04 initial server setup tutorial.
      • Install a LEMP stack: WordPress will need a web server, a database, and PHP in order to correctly function. Setting up a LEMP stack (Linux, Nginx, MySQL, and PHP) fulfills all of these requirements. Follow this tutorial to install and configure this software.

      Rather than setting up these components yourself, you can quickly provision Ubuntu 20.04 server that already has a LEMP stack installed with DigitalOcean’s LEMP 1-click install app.

      Be aware, though, that this tutorial still assumes you have an administrative sudo user and an Nginx server block configured on your server. Even with a server provisioned with the LEMP 1-click app, you’ll need to follow Steps 1, 2, 3, and 5 of our Ubuntu 20.04 initial server setup tutorial. You’ll also need to complete Step 4 of our guide on installing the LEMP Stack on Ubuntu 20.04 to configure an Nginx server block and configure Nginx to use the PHP Processor

      • Secure your site with SSL: WordPress serves dynamic content and handles user authentication and authorization. TLS/SSL is the technology that allows you to encrypt the traffic from your site so that your connection is secure. The way you set up SSL will depend on whether you have a domain name for your site.
        • If you have a domain name, the easiest way to secure your site is with Let’s Encrypt, which provides free, trusted certificates. Follow our Let’s Encrypt guide for Nginx to set this up.
        • If you do not have a domain and you’re using this configuration for testing or personal use, you can use a self-signed certificate instead. This provides the same type of encryption, but without the domain validation. Follow our self-signed SSL guide for Nginx to get set up.

      When you are finished with setup, log in to your server as the sudo user to continue.

      Step 1 — Creating a MySQL Database and User for WordPress

      WordPress uses MySQL to manage and store site and user information. Although you already have MySQL installed, let’s create a database and a user for WordPress to use.

      To get started, log in to the MySQL root (administrative) account. If MySQL is configured to use the auth_socket authentication plugin (which is default), you can log in to the MySQL administrative account using sudo:

      If you have changed the authentication method to use a password for the MySQL root account, use the following command instead:

      You will be prompted for the password you set for the MySQL root account.

      Once logged in, create a separate database that WordPress can control. You can call this whatever you would like, but we will be using wordpress in this guide to keep it simple. You can create a database for WordPress by entering:

      • CREATE DATABASE wordpress DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;

      Note: Every MySQL statement must end in a semi-colon (;). If you’ve encountered an error, check to make sure the semicolon is present.

      Next, let’s create a separate MySQL user account that we will use exclusively to operate on our new database. Creating single-purpose databases and accounts is a good idea from a management and security standpoint. We’ll use the name wordpressuser in this guide — feel free to change this if you’d like.

      In the following command, you are going to create an account, set a password, and grant access to the database you created. Remember to choose a strong password here:

      • CREATE USER 'wordpressuser'@'localhost' IDENTIFIED BY 'password';
      • GRANT ALL ON wordpress.* TO 'wordpressuser'@'localhost’;

      You now have a database and user account, each made specifically for WordPress.

      With the database tasks complete, let’s exit out of MySQL by typing:

      The MySQL session will exit, returning you to the regular Linux shell.

      Step 2 — Installing Additional PHP Extensions

      When setting up the LEMP stack, it required a very minimal set of extensions to get PHP to communicate with MySQL. WordPress and many of its plugins leverage additional PHP extensions, and you’ll use a few more in this tutorial.

      Let’s download and install some of the most popular PHP extensions for use with WordPress by typing:

      • sudo apt install php-curl php-gd php-intl php-mbstring php-soap php-xml php-xmlrpc php-zip

      Note: Each WordPress plugin has its own set of requirements. Some may require additional PHP extension packages to be installed. Check your plugin documentation to discover its PHP requirements. If they are available, they can be installed with apt as demonstrated above.

      When you are finished installing the extensions, restart the PHP-FPM process so that the running PHP processor can leverage the newly installed features:

      • sudo systemctl restart php7.4-fpm

      You now have all of the PHP extensions needed, installed on the server.

      Step 3 — Configuring Nginx

      Next, let’s make a few adjustments to our Nginx server block files. Based on the prerequisite tutorials, you should have a configuration file for your site in the /etc/nginx/sites-available/ directory configured to respond to your server’s domain name or IP address and protected by a TLS/SSL certificate. We’ll use /etc/apache2/sites-available/wordpress as an example here, but you should substitute the path to your configuration file where appropriate.

      Additionally, we will use /var/www/wordpress as the root directory of our WordPress install in this guide. Again, you should use the web root specified in your own configuration.

      Note: It’s possible you are using the /etc/nginx/sites-available/default default configuration (with /var/www/html as your web root). This is fine to use if you’re only going to host one website on this server. If not, it’s best to split the necessary configuration into logical chunks, one file per site.

      Open your site’s server block file with sudo privileges to begin:

      • sudo nano /etc/nginx/sites-available/wordpress

      Within the main server block, let’s add a few location blocks.

      Start by creating exact-matching location blocks for requests to /favicon.ico and /robots.txt, both of which you do not want to log requests for.

      Use a regular expression location to match any requests for static files. We will again turn off the logging for these requests and will mark them as highly cacheable, since these are typically expensive resources to serve. You can adjust this static files list to contain any other file extensions your site may use:

      /etc/nginx/sites-available/wordpress

      server {
          . . .
      
          location = /favicon.ico { log_not_found off; access_log off; }
          location = /robots.txt { log_not_found off; access_log off; allow all; }
          location ~* .(css|gif|ico|jpeg|jpg|js|png)$ {
              expires max;
              log_not_found off;
          }
          . . .
      }
      

      Inside of the existing location / block, let’s adjust the try_files list. Comment out the default setting by prepending the line with a pound sign (#) and then add the highlighted line. This way, instead of returning a 404 error as the default option, control is passed to the index.php file with the request arguments.

      This should look something like this:

      /etc/nginx/sites-available/wordpress

      server {
          . . .
          location / {
              #try_files $uri $uri/ =404;
              try_files $uri $uri/ /index.php$is_args$args;
          }
          . . .
      }
      

      When you are finished, save and close the file.

      Now, let’s check our configuration for syntax errors by typing:

      If no errors were reported, reload Nginx by typing:

      • sudo systemctl reload nginx

      Next, let’s download and set up WordPress.

      Step 4 — Downloading WordPress

      Now that your server software is configured, let’s download and set up WordPress. For security reasons, it is always recommended to get the latest version of WordPress directly from the project’s website.

      Change into a writable directory and then download the compressed release by typing:

      This changes your directory to the temporary folder. Then, enter the following command to download the latest version of WordPress in a compressed file:

      • curl -LO https://wordpress.org/latest.tar.gz

      Note: The -LO flag is used to get directly to the source of the compressed file. -L ensures that fetching the file is successful in the case of redirects, and -O writes the output of our remote file with a local file that has the same name. To learn more about curl commands, visit How to Download Files with cURL

      Extract the compressed file to create the WordPress directory structure:

      You will be moving these files into our document root momentarily, but before you do, let’s copy over the sample configuration file to the filename that WordPress actually reads:

      • cp /tmp/wordpress/wp-config-sample.php /tmp/wordpress/wp-config.php

      Now, let’s copy the entire contents of the directory into our document root. We’re using the -a flag to make sure our permissions are maintained, and a dot at the end of our source directory to indicate that everything within the directory should be copied (including hidden files):

      • sudo cp -a /tmp/wordpress/. /var/www/wordpress

      Now that our files are in place, you’ll assign ownership to the www-data user and group. This is the user and group that Nginx runs as, and Nginx will need to be able to read and write WordPress files in order to serve the website and perform automatic updates:

      • sudo chown -R www-data:www-data /var/www/wordpress

      Files are now in the server’s document root and have the correct ownership, but you still need to complete some additional configuration.

      Step 5 — Setting up the WordPress Configuration File

      Next, let’s make some changes to the main WordPress configuration file.

      When you open the file, you’ll start by adjusting some secret keys to provide some security for our installation. WordPress provides a secure generator for these values so that you don’t have to come up with values on your own. These are only used internally, so it won’t hurt usability to have complex, secure values here.

      To grab secure values from the WordPress secret key generator, type:

      • curl -s https://api.wordpress.org/secret-key/1.1/salt/

      You will get back unique values that look something like this:

      Warning: It is important that you request unique values each time. Do NOT copy the values shown below!

      Output

      define('AUTH_KEY', '1jl/vqfs<XhdXoAPz9 DO NOT COPY THESE VALUES c_j{iwqD^<+c9.k<J@4H'); define('SECURE_AUTH_KEY', 'E2N-h2]Dcvp+aS/p7X DO NOT COPY THESE VALUES {Ka(f;rv?Pxf})CgLi-3'); define('LOGGED_IN_KEY', 'W(50,{W^,OPB%PB<JF DO NOT COPY THESE VALUES 2;y&,2m%3]R6DUth[;88'); define('NONCE_KEY', 'll,4UC)7ua+8<!4VM+ DO NOT COPY THESE VALUES #`DXF+[$atzM7 o^-C7g'); define('AUTH_SALT', 'koMrurzOA+|L_lG}kf DO NOT COPY THESE VALUES 07VC*Lj*lD&?3w!BT#-'); define('SECURE_AUTH_SALT', 'p32*p,]z%LZ+pAu:VY DO NOT COPY THESE VALUES C-?y+K0DK_+F|0h{!_xY'); define('LOGGED_IN_SALT', 'i^/G2W7!-1H2OQ+t$3 DO NOT COPY THESE VALUES t6**bRVFSD[Hi])-qS`|'); define('NONCE_SALT', 'Q6]U:K?j4L%Z]}h^q7 DO NOT COPY THESE VALUES 1% ^qUswWgn+6&xqHN&%');

      These are configuration lines that you can paste directly in your configuration file to set secure keys. Copy the output you received now.

      Now, open the WordPress configuration file:

      • sudo nano /var/www/wordpress/wp-config.php

      Find the section that contains the dummy values for those settings. It will look something like this:

      /var/www/wordpress/wp-config.php

      . . .
      
      define('AUTH_KEY',         'put your unique phrase here');
      define('SECURE_AUTH_KEY',  'put your unique phrase here');
      define('LOGGED_IN_KEY',    'put your unique phrase here');
      define('NONCE_KEY',        'put your unique phrase here');
      define('AUTH_SALT',        'put your unique phrase here');
      define('SECURE_AUTH_SALT', 'put your unique phrase here');
      define('LOGGED_IN_SALT',   'put your unique phrase here');
      define('NONCE_SALT',       'put your unique phrase here');
      
      . . .
      

      Delete those lines and paste in the values you copied from the command line:

      /var/www/wordpress/wp-config.php

      . . .
      
      define('AUTH_KEY',         'VALUES COPIED FROM THE COMMAND LINE');
      define('SECURE_AUTH_KEY',  'VALUES COPIED FROM THE COMMAND LINE');
      define('LOGGED_IN_KEY',    'VALUES COPIED FROM THE COMMAND LINE');
      define('NONCE_KEY',        'VALUES COPIED FROM THE COMMAND LINE');
      define('AUTH_SALT',        'VALUES COPIED FROM THE COMMAND LINE');
      define('SECURE_AUTH_SALT', 'VALUES COPIED FROM THE COMMAND LINE');
      define('LOGGED_IN_SALT',   'VALUES COPIED FROM THE COMMAND LINE');
      define('NONCE_SALT',       'VALUES COPIED FROM THE COMMAND LINE');
      
      . . .
      

      Next, let’s modify some of the database connection settings at the beginning of the file. You’ll have to adjust the database name, the database user, and the associated password that was configured within MySQL.

      The other change you should make is to set the method that WordPress uses to write to the filesystem. Since you’ve given the web server permission to write where it needs to, you can explicitly set the filesystem method to “direct”. Failure to set this with our current settings would result in WordPress prompting for FTP credentials when we perform some actions. Add this setting below the database connection settings, or anywhere else in the file:

      /var/www/wordpress/wp-config.php

      . . .
      
      define( 'DB_NAME', 'wordpress' );
      
      /** MySQL database username */
      define( 'DB_USER', 'wordpressuser' );
      
      /** MySQL database password */
      define( 'DB_PASSWORD', 'password' );
      
      . . .
      
      define( 'FS_METHOD', 'direct' );
      

      Save and close the file when you’re done.

      Step 6 — Completing the Installation Through the Web Interface

      Now that the server configuration is complete, you can finish up the installation through WordPress’ web interface.

      In your web browser, navigate to your server’s domain name or public IP address:

      http://server_domain_or_IP/wordpress
      

      Select the language you would like to use:

      WordPress language selection

      Next, you will come to the main setup page.

      Select a name for your WordPress site and choose a username (it is recommended not to choose something like “admin” for security purposes). A strong password is generated automatically. Save this password or select an alternative strong password.

      Enter your email address and select whether you want to discourage search engines from indexing your site:

      WordPress setup installation

      When you click ahead, you will be taken to a page that prompts you to log in:

      WordPress login prompt

      Once you log in, you will be taken to the WordPress administration dashboard:

      WordPress login prompt

      Conclusion

      WordPress should be installed and ready to use! Some common next steps are to choose the permalinks setting for your posts (can be found in Settings > Permalinks) or to select a new theme (in Appearance > Themes). If this is your first time using WordPress, explore the interface a bit to get acquainted with your new CMS.

      If you’re looking for a one-click solution to install a WordPress Droplet, learn more about the WordPress One-Click App.



      Source link

      Cara Menginstal Linux, Nginx, MySQL, PHP (tumpukan LEMP) pada Ubuntu 20.04


      Pengantar

      Tumpukan perangkat lunak LEMP adalah sekumpulan perangkat lunak yang dapat digunakan untuk menyajikan laman web dan aplikasi web dinamis yang ditulis dalam PHP. Ini adalah akronim yang mendeskripsikan suatu sistem operasi Linux, dengan server web Nginx (diucapkan seperti “Engine-X”). Data backend disimpan di dalam basis data MySQL, dan pemrosesan dinamis ditangani oleh PHP.

      Panduan ini menunjukkan cara menginstal tumpukan LEMP pada server Ubuntu 20.04. Sistem operasi Ubuntu menangani persyaratan pertama. Kami akan menjelaskan cara menjadikan komponen lainnya menjadi aktif dan berjalan.

      Prasyarat

      Untuk menyelesaikan tutorial ini, Anda akan memerlukan akses ke server Ubuntu 20.04 sebagai pengguna sudo non-root reguler, dan firewall yang aktif pada server Anda. Untuk menyiapkan ini, Anda dapat mengikuti panduan penyiapan server awal untuk Ubuntu 20.04 dari kami.

      Langkah 1 – Menginstal Server Web Nginx

      Untuk menampilkan laman web kepada pengunjung situs kita, kita akan menggunakan Nginx, yang merupakan server web berkinerja tinggi. Kita akan menggunakan manajer paket apt untuk memperoleh perangkat lunak ini.

      Karena ini adalah kali pertama kita menggunakan apt untuk sesi ini, maka mulailah dengan memperbarui indeks paket server Anda. Setelah itu, Anda dapat menggunakan apt install untuk menginstal Nginx:

      • sudo apt update
      • sudo apt install nginx

      Saat diminta, tekan Y untuk mengonfirmasi bahwa Anda ingin menginstal Nginx. Setelah instalasi selesai, server web Nginx akan menjadi aktif dan berjalan pada server Ubuntu 20.04 Anda.

      Jika Anda memiliki firewall ufw yang telah aktif, seperti yang disarankan dalam panduan penyiapan server awal kami, Anda akan perlu mengizinkan koneksi ke Nginx. Nginx mendaftarkan beberapa profil aplikasi UFW yang berbeda saat instalasi. Untuk memeriksa profil UFW mana yang tersedia, jalankan:

      Output

      Available applications: Nginx Full Nginx HTTP Nginx HTTPS OpenSSH

      Anda disarankan untuk mengaktifkan profil paling ketat yang masih akan mengizinkan lalu lintas yang Anda perlukan. Karena Anda belum mengonfigurasi SSL untuk server Anda dalam panduan ini, Anda hanya akan perlu mengizinkan lalu lintas HTTP reguler pada porta 80.

      Aktifkan ini dengan mengetik:

      • sudo ufw allow 'Nginx HTTP'

      Anda dapat memverifikasi perubahan dengan menjalankan:

      Keluaran perintah ini akan menunjukkan bahwa lalu lintas HTTP kini diizinkan:

      Output

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

      Dengan penambahan aturan firewall yang baru ini, Anda dapat menguji apakah server telah aktif dan berjalan dengan mengakses nama domain server Anda atau alamat IP publik pada peramban web Anda.

      Jika Anda tidak memiliki nama domain yang mengarah ke server Anda dan Anda tidak mengetahui alamat IP publik server Anda, Anda dapat menemukannya dengan menjalankan perintah berikut:

      • ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's//.*$//'

      Ini akan mencetak beberapa alamat IP. Anda dapat mencoba setiap alamat tersebut secara satu per satu di peramban web Anda.

      Sebagai alternatif, Anda dapat memeriksa alamat IP mana yang dapat diakses, sebagaimana dilihat dari lokasi lain di internet:

      Ketik alamat yang Anda terima di peramban web Anda dan ini akan membawa Anda ke laman landas asali Nginx:

      http://server_domain_or_IP
      

      Laman asali Nginx

      Jika Anda melihat laman ini, ini berarti Anda telah berhasil menginstal Nginx dan mengaktifkan lalu lintas HTTP untuk server web Anda.

      Langkah 2 — Menginstal MySQL

      Setelah server web hidup dan berfungsi, Anda perlu menginstal sistem basis data agar dapat menyimpan dan mengelola data untuk situs Anda. MySQL adalah sistem manajemen basis data populer yang digunakan dalam lingkungan PHP.

      Sekali lagi, gunakan apt untuk memperoleh dan menginstal perangkat lunak ini:

      • sudo apt install mysql-server

      Ketika diminta, lakukan konfirmasi instalasi dengan mengetik Y, lalu ENTER.

      Ketika instalasi selesai, Anda disarankan untuk menjalankan skrip keamanan yang sudah terinstal sebelumnya dengan MySQL. Skrip ini akan menghapus beberapa pengaturan asali yang tidak aman dan mengunci akses ke sistem basis data Anda. Mulai skrip interaktif dengan menjalankan:

      • sudo mysql_secure_installation

      Anda akan ditanya apakah Anda ingin mengonfigurasi VALIDATE PASSWORD PLUGIN.

      Catatan: Mengaktifkan fitur ini merupakan keputusan yang Anda pertimbangkan sendiri. Jika diaktifkan, kata sandi yang tidak cocok dengan kriteria yang ditentukan akan ditolak oleh MySQL dengan suatu kesalahan. Akan lebih aman jika Anda tetap menonaktifkan validasi, tetapi Anda harus selalu menggunakan kata sandi yang kuat dan unik untuk kredensial basis data.

      Jawab Y untuk ya, atau jawaban lain untuk melanjutkan tanpa mengaktifkan.

      VALIDATE PASSWORD PLUGIN can be used to test passwords
      and improve security. It checks the strength of password
      and allows the users to set only those passwords which are
      secure enough. Would you like to setup VALIDATE PASSWORD plugin?
      
      Press y|Y for Yes, any other key for No:
      

      Jika Anda menjawab “ya”, Anda akan diminta untuk memilih tingkat validasi kata sandi. Harap ingat bahwa jika Anda memasukkan 2 sebagai tingkat terkuat, Anda akan menjumpai kesalahan saat berusaha menentukan kata sandi yang tidak mengandung angka, huruf kapital dan huruf kecil, serta karakter khusus, atau kata sandi yang berdasarkan pada kata-kata kamus umum.

      There are three levels of password validation policy:
      
      LOW    Length >= 8
      MEDIUM Length >= 8, numeric, mixed case, and special characters
      STRONG Length >= 8, numeric, mixed case, special characters and dictionary              file
      
      Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 1
      

      Terlepas dari pilihan pengaturan VALIDATE PASSWORD PLUGIN, server Anda akan meminta Anda untuk memilih dan mengonfirmasi kata sandi untuk pengguna root MySQL. Ini tidak sama dengan root sistem. Pengguna root basis data adalah pengguna administratif dengan privilese penuh terhadap sistem basis data. Meskipun metode autentikasi asali untuk pengguna root MySQL mengecualikan penggunaan kata sandi, sekalipun kata kata sandi sudah dibuat, Anda tetap harus menentukan kata sandi yang kuat di sini sebagai langkah keamanan tambahan. Kita akan membahas hal ini sebentar lagi.

      Jika Anda mengaktifkan validasi kata sandi, Anda akan diperlihatkan kekuatan kata sandi untuk kata sandi root yang baru saja Anda masukkan dan server Anda akan bertanya apakah Anda ingin melanjutkan dengan kata sandi itu. Jika Anda puas dengan kata sandi ini, tekan Y untuk “ya” di prompt:

      Estimated strength of the password: 100
      Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : y
      

      Untuk pertanyaan lainnya, tekan Y dan tombol ENTER pada setiap pertanyaan. Ini akan menghapus sebagian pengguna anonim dan basis data percobaan, menonaktifkan log masuk root dari jarak jauh, dan memuat aturan-aturan baru ini sehingga MySQL segera menerapkan perubahan yang Anda buat.

      Setelah Anda selesai, lakukan percobaan apakah Anda dapat melakukan log masuk ke konsol MySQL dengan mengetik:

      Ini akan menghubungkan ke server MySQL sebagai root pengguna basis data administratif, yang ditentukan berdasarkan penggunaan sudo saat menjalankan perintah ini. Anda akan melihat keluaran seperti ini:

      Output

      Welcome to the MySQL monitor. Commands end with ; or g. Your MySQL connection id is 22 Server version: 8.0.19-0ubuntu5 (Ubuntu) Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved. Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners. Type 'help;' or 'h' for help. Type 'c' to clear the current input statement. mysql>

      Untuk keluar dari konsol MySQL, ketik:

      Perhatikan bahwa Anda tidak perlu memberikan kata sandi untuk terhubung sebagai pengguna root, meskipun Anda telah menentukannya saat menjalankan skrip mysql_secure_installation. Hal itu dikarenakan metode autentikasi asali untuk pengguna MySQL administratif adalah unix_socket alih-alih kata sandi. Meskipun awalnya ini mungkin terlihat seperti masalah keamanan, tetapi ini membuat server basis data menjadi lebih aman karena pengguna yang diizinkan melakukan log masuk sebagai pengguna MySQL root hanya pengguna sistem dengan privilese sudo yang terhubung dari konsol atau melalui aplikasi yang berjalan dengan privilese yang sama. Dalam praktiknya, itu berarti Anda tidak akan dapat menggunakan pengguna root basis data administratif untuk terhubung dari aplikasi PHP. Pengaturan kata sandi untuk akun MySQL root berfungsi sebagai perlindungan, apabila metode autentikasi asali diubah dari unix_socket menjadi kata sandi.

      Untuk keamanan yang lebih baik, saran terbaiknya adalah memiliki akun pengguna khusus dengan pengaturan privilese yang lebih sempit untuk setiap basis data, terutama jika Anda berencana memiliki beberapa basis data di mana server Anda adalah hosnya.

      Catatan: Saat menyusun tulisan ini, pustaka PHP MySQL asli mysqlnd tidak mendukung caching_sha2_authentication, metode autentikasi asali untuk MySQL 8. Karena itu, saat menciptakan pengguna basis data untuk aplikasi PHP di MySQL 8, Anda perlu memastikan pengguna telah dikonfigurasi untuk menggunakan mysql_native_password. Kami akan mendemonstrasikan caranya di Langkah 6.

      Server MySQL Anda kini telah terinstal dan terlindungi. Selanjutnya, kita akan menginstal PHP, komponen terakhir dalam tumpukan LEMP.

      Langkah 3 — Menginstal PHP

      Anda telah menginstal Nginx untuk menyajikan konten Anda dan MySQL telah terinstal untuk menyimpan dan mengelola data Anda. Sekarang, Anda dapat menginstal PHP untuk memproses kode dan menghasilkan konten dinamis untuk server web.

      Walaupun Apache menyematkan penafsir PHP dalam setiap permintaan, Nginx membutuhkan program eksternal untuk menangani pemrosesan PHP dan bertindak sebagai jembatan antara penafsir PHP itu sendiri dan server web. Ini memungkinkan kinerja keseluruhan yang lebih baik di sebagian besar situs web berbasis PHP, tetapi ini membutuhkan konfigurasi tambahan. Anda akan perlu menginstal php-fpm, yang merupakan singkatan dari “PHP fastCGI process manager”, dan menyuruh Nginx untuk meneruskan permintaan PHP ini ke perangkat lunak ini untuk pemrosesan.. Selain itu, Anda akan membutuhkan php-mysql, suatu modul PHP yang mengizinkan PHP untuk berkomunikasi dengan basis data berbasis MySQL. Paket PHP inti akan secara otomatis terinstal sebagai dependensi.

      Untuk menginstal paket php-fpm dan php-mysql, jalankan:

      • sudo apt install php-fpm php-mysql

      Saat diminta, ketik Y dan ENTER untuk mengonfirmasi instalasi.

      Anda sekarang telah menginstal komponen PHP Anda. Selanjutnya, Anda akan mengonfigurasi Nginx untuk menggunakannya.

      Langkah 4 — Mengonfigurasi Nginx untuk Menggunakan Prosesor PHP

      Ketika menggunakan server web Nginx, kita dapat menciptakan blok server (serupa dengan hos virtual di Apache) untuk mengenkapsulasi detail konfigurasi dan menjadi hos untuk lebih dari satu domain pada suatu server tunggal. Dalam panduan ini, kita akan menggunakan your_domain sebagai nama domain contoh. Untuk mempelajari lebih lanjut tentang menyiapkan nama domain dengan DigitalOcean, silakan lihat pengantar DNS DigitalOcean dari kami.

      Pada Ubuntu 20.04, Nginx memiliki satu blok server yang diaktifkan secara asali dan dikonfigurasi untuk menampilkan dokumen dari direktori di /var/www/html. Walaupun ini berjalan baik untuk situs tunggal, tetapi ini dapat menjadi sulit untuk dikelola jika Anda menjadi hos dari beberapa situs. Alih-alih memodifikasi /var/www/html, kita akan menciptakan struktur direktori di dalam /var/www untuk situs web your_domain, dengan membiarkan /var/www/html di tempatnya sebagai direktori asali yang akan ditampilkan jika permintaan klien tidak cocok dengan situs lain apa pun.

      Buat direktori web root untuk your_domain sebagai berikut:

      • sudo mkdir /var/www/your_domain

      Selanjutnya, tetapkan kepemilikan direktori dengan variabel lingkungan $USER, yang akan merujuk pada pengguna sistem Anda saat ini:

      • sudo chown -R $USER:$USER /var/www/your_domain

      Lalu, buka berkas konfigurasi baru dalam direktori sites-available di Nginx dengan menggunakan editor baris perintah yang Anda sukai. Di sini, kita akan menggunakan nano:

      • sudo nano /etc/nginx/sites-available/your_domain

      Ini akan menciptakan berkas kosong yang baru. Tempelkan konfigurasi dasar berikut:

      /etc/nginx/sites-available/your_domain

      server {
          listen 80;
          server_name your_domain www.your_domain;
          root /var/www/your_domain;
      
          index index.html index.htm index.php;
      
          location / {
              try_files $uri $uri/ =404;
          }
      
          location ~ .php$ {
              include snippets/fastcgi-php.conf;
              fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
           }
      
          location ~ /.ht {
              deny all;
          }
      
      }
      
      
      

      Berikut ini adalah apa yang dilakukan oleh masing-masing arahan dan blok lokasi:

      • listen — Menetapkan porta yang akan didengarkan oleh Nginx. Dalam kasus ini, Nginx akan mendengarkan porta 80, porta asali untuk HTTP.
      • root — Menentukan root dokumen di mana berkas yang ditampilkan oleh situs web ini disimpan.
      • index — Menetapkan urutan seperti apa yang akan diprioritaskan oleh Nginx untuk situs web ini. Merupakan suatu praktik umum untuk menempatkan berkas index.html dengan keutamaan lebih tinggi dari berkas index.php untuk memungkinkan penyiapan laman landas pemeliharaan dengan cepat di dalam aplikasi PHP. Anda dapat menyesuaikan pengaturan ini supaya lebih sesuai dengan kebutuhan aplikasi Anda.
      • server_name — Menetapkan nama domain mana dan/atau alamat IP mana yang blok server in akan tanggapi. Mengarahkan arahan ini ke nama domain server atau alamat IP publik server Anda.
      • location / — Blok lokasi pertama mencakup arahan try_files yang memeriksa adanya berkas atau direktori yang cocok dengan permintaan URL. Jika Nginx tidak dapat menemukan sumber daya yang sesuai, kesalahan 404 akan ditampilkan.
      • location ~ .php$ — Blok lokasi ini menangani pemrosesan PHP aktual dengan mengarahkan Nginx ke berkas konfigurasi fastcgi-php.conf dan berkas php7.4-fpm.sock, yang menyatakan soket yang mana yang terasosiasi dengan php-fpm.
      • location ~ /.ht — Blok lokasi terakhir yang menangani berkas .htaccess yang tidak diproses oleh Nginx. Dengan menambahkan arahan deny all, jika ada berkas .htaccess ternyata menemukan jalan ke root dokumen, berkas itu tidak akan disajikan kepada pengunjung.

      Setelah Anda selesai mengedit, simpan dan tutup berkas. Jika menggunakan nano, Anda dapat melakukan itu dengan menekan CTRL+X lalu y dan ENTER untuk mengonfirmasi.

      Aktifkan konfigurasi Anda dengan menautkannya ke berkas konfigurasi dari direktori sites-enabled Nginx:

      • sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/

      Ini akan memberi tahu Nginx untuk menggunakan konfigurasi itu saat dimuat ulang untuk kali berikutnya. Anda dapat menguji konfigurasi Anda untuk memeriksa kesalahan sintaks dengan mengetik:

      Jika ada kesalahan yang dilaporkan, kembalilah ke berkas konfigurasi Anda untuk meninjau kontennya sebelum melanjutkan.

      Saat Anda siap, muat ulang Nginx untuk menerapkan perubahan:

      • sudo systemctl reload nginx

      Situs web Anda yang baru kini sudah aktif, tetapi root web /var/www/your_domain masih kosong. Buat berkas index.html di dalam lokasi itu sehingga kita dapat menguji apakah blok server baru Anda bekerja sesuai harapan:

      • nano /var/www/your_domain/index.html

      Sertakan konten berikut di dalam berkas ini:

      /var/www/your_domain/index.html

      <html>
        <head>
          <title>your_domain website</title>
        </head>
        <body>
          <h1>Hello World!</h1>
      
          <p>This is the landing page of <strong>your_domain</strong>.</p>
        </body>
      </html>
      

      Sekarang, buka peramban Anda dan akses nama domain atau alamat IP server Anda, seperti yang tercantum di arahan server_name di dalam berkas konfigurasi blok server Anda:

      http://server_domain_or_IP
      

      Anda akan melihat sebuah laman seperti ini:

      Blok server Nginx

      Jika Anda melihat laman ini, ini berarti blok server Nginx Anda bekerja sesuai harapan.

      Anda dapat meninggalkan berkas ini di lokasinya saat ini sebagai laman landas sementara untuk aplikasi Anda sampai Anda menyiapkan berkas index.php untuk menggantinya. Setelah Anda melakukannya, ingat untuk menghapus atau mengganti nama berkas index.html dari root dokumen Anda, karena berkas ini lebih diutamakan daripada berkas index.php secara asali.

      Tumpukan LEMP Anda kini telah dikonfigurasi dengan sempurna. Pada langkah selanjutnya, kita akan menciptakan skrip PHP untuk menguji apakah Nginx dapat benar-benar menangani berkas .php di dalam situs web Anda yang baru saja dikonfigurasi.

      Langkah 5 — Menguji PHP dengan Nginx

      Tumpukan LEMP Anda sekarang harusnya telah selesai disiapkan. Anda dapat mengujinya untuk memvalidasi apakah Nginx dapat dengan benar menyerahkan berkas .php ke prosesor PHP Anda.

      Anda dapat melakukan ini dengan menciptakan berkas PHP percobaan di dalam root dokumen Anda. Buka berkas baru yang bernama info.php di dalam root dokumen Anda di dalam editor teks Anda:

      • nano /var/www/your_domain/info.php

      Ketik atau tempel baris berikut ke berkas baru. Ini adalah kode PHP yang valid yang akan memberikan informasi tentang server Anda:

      /var/www/your_domain/info.php

      <?php
      phpinfo();
      

      Setelah Anda selesai, simpan dan tutup berkas dengan menekan CTRL+X lalu y dan ENTER untuk mengonfirmasi.

      Anda sekarang dapat mengakses laman ini di peramban web Anda dengan mengunjungi nama domain atau alamat IP publik yang telah Anda atur di dalam berkas konfigurasi Nginx Anda, diikuti dengan /info.php:

      http://server_domain_or_IP/info.php
      

      Anda akan melihat laman web yang berisi informasi detail tentang server Anda:

      PHPInfo Ubuntu 20.04

      Setelah memeriksa informasi yang relevan mengenai server PHP Anda melalui laman itu, saran terbaik untuk Anda adalah hapus berkas yang Anda ciptakan karena berkas tersebut mengandung informasi sensitif tentang lingkungan PHP dan server Ubuntu Anda. Anda dapat menggunakan rm untuk menghapus berkas itu:

      • sudo rm /var/www/your_domain/info.php

      Anda selalu dapat meregenerasi berkas ini jika Anda membutuhkannya nanti.

      Langkah 6 — Menguji Koneksi Basis Data dari PHP (Opsional)

      Jika Anda ingin menguji apakah PHP dapat terhubung ke MySQL dan menjalankan kueri basis data, Anda dapat menciptakan tabel percobaan dengan kueri dan data semu sebagai kontennya dari skrip PHP. Sebelum melakukan itu, kita perlu menciptakan basis data percobaan dan pengguna MySQL baru yang dikonfigurasi dengan benar untuk mengaksesnya.

      Saat menyusun tulisan ini, pustaka PHP MySQL asli mysqlnd tidak mendukung caching_sha2_authentication, metode autentikasi asali untuk MySQL 8. Kita akan perlu menciptakan pengguna baru dengan metode autentikasi mysql_native_password agar dapat terhubung ke basis data MySQL dari PHP.

      Kita akan menciptakan basis data bernama example_database dan pengguna bernama example_user, tetapi Anda dapat mengganti nama-nama ini dengan nilai yang berbeda.

      Pertama, hubungkan ke konsol MySQL menggunakan akun root:

      Untuk menciptakan basis data baru, jalankan perintah berikut dari konsol MySQL:

      • CREATE DATABASE example_database;

      Sekarang Anda dapat menciptakan pengguna baru dan memberikan mereka privilese penuh pada basis data khusus yang baru saja Anda ciptakan.

      Perintah berikut menciptakan pengguna baru bernama example_user, yang menggunakan mysql_native_password sebagai metode autentikasi asali. Kita mendefinisikan kata sandi pengguna ini sebagai password, tetapi Anda harus mengganti nilai ini dengan kata sandi pilihan Anda yang aman.

      • CREATE USER 'example_user'@'%' IDENTIFIED WITH mysql_native_password BY 'password';

      Sekarang, kita perlu memberikan izin terhadap basis data example_database kepada pengguna ini:

      • GRANT ALL ON example_database.* TO 'example_user'@'%';

      Ini akan memberikan pengguna example_user privilese penuh terhadap basis data example_database database, yang juga mencegah pengguna ini untuk tidak membuat atau memodifikasi basis data lainnya di server Anda.

      Sekarang, keluar dari shell MySQL dengan:

      Anda dapat menguji apakah pengguna baru memiliki izin yang tepat dengan melakukan log masuk ke konsol MySQL lagi, kali ini dengan menggunakan kredensial pengguna khusus:

      Perhatikan tanda -p dalam perintah ini, yang akan meminta Anda kata sandi yang digunakan saat menciptakan pengguna example_user. Setelah log masuk ke konsol MySQL, pastikan Anda memiliki akses ke basis data example_database:

      Ini akan menampilkan keluaran berikut:

      Output

      +--------------------+ | Database | +--------------------+ | example_database | | information_schema | +--------------------+ 2 rows in set (0.000 sec)

      Selanjutnya, kita akan menciptakan tabel percobaan bernama todo_list. Dari konsol MySQL, jalankan pernyataan berikut:

      • CREATE TABLE example_database.todo_list (
      • item_id INT AUTO_INCREMENT,
      • content VARCHAR(255),
      • PRIMARY KEY(item_id)
      • );

      Masukkan beberapa baris konten ke dalam tabel percobaan. Anda mungkin ingin mengulangi perintah selanjutnya beberapa kali lagi, dengan menggunakan nilai yang berbeda:

      • INSERT INTO example_database.todo_list (content) VALUES ("My first important item");

      Untuk memastikan data berhasil tersimpan di tabel, jalankan:

      • SELECT * FROM example_database.todo_list;

      Anda akan melihat keluaran berikut:

      Output

      +---------+--------------------------+ | item_id | content | +---------+--------------------------+ | 1 | My first important item | | 2 | My second important item | | 3 | My third important item | | 4 | and this one more thing | +---------+--------------------------+ 4 rows in set (0.000 sec)

      Setelah memastikan Anda memiliki data yang valid dalam tabel percobaan, Anda dapat keluar dari konsol MySQL:

      Sekarang Anda dapat menciptakan skrip PHP yang akan terhubung ke MySQL dan melakukan kueri untuk konten Anda. Buat berkas PHP baru pada direktori root web khusus Anda menggunakan editor pilihan Anda. Kita akan menggunakan nano untuk itu:

      • nano /var/www/your_domain/todo_list.php

      Skrip PHP berikut terhubung ke basis data MySQL dan melakukan kueri untuk konten tabel todo_list, yang menampilkan hasilnya dalam sebuah daftar. Jika ada masalah dengan koneksi basis data, akan dilakukan pengecualian. Salin konten ini ke skrip todo_list.php:

      /var/www/your_domain/todo_list.php

      <?php
      $user = "example_user";
      $password = "password";
      $database = "example_database";
      $table = "todo_list";
      
      try {
        $db = new PDO("mysql:host=localhost;dbname=$database", $user, $password);
        echo "<h2>TODO</h2><ol>";
        foreach($db->query("SELECT content FROM $table") as $row) {
          echo "<li>" . $row['content'] . "</li>";
        }
        echo "</ol>";
      } catch (PDOException $e) {
          print "Error!: " . $e->getMessage() . "<br/>";
          die();
      }
      

      Simpan dan tutup berkas setelah Anda selesai mengedit.

      Anda dapat mengakses laman ini di peramban web Anda dengan mengunjungi nama domain atau alamat IP publik yang dikonfigurasi untuk situs web Anda, diikuti dengan /todo_list.php:

      http://server_domain_or_IP/todo_list.php
      

      Anda akan melihat laman seperti ini, yang menunjukkan konten yang telah Anda masukkan ke dalam tabel percobaan Anda:

      Contoh todo list PHP

      Ini berarti lingkungan PHP Anda telah siap terhubung dan berinteraksi dengan server MySQL.

      Kesimpulan

      Dalam panduan ini, kita telah membangun fondasi yang fleksibel untuk menyajikan aplikasi dan situs web PHP kepada pengunjung Anda, dengan menggunakan Nginx sebagai server web dan MySQL sebagai sistem basis data.



      Source link

      Comment installer Linux, Nginx, MySQL, PHP (pile LEMP) sur Ubuntu 20.04 [Démarrage rapide]


      Introduction

      Dans ce guide de démarrage rapide, nous allons installer une pile LEMP sur un serveur Ubuntu 20.04.

      Pour une version plus détaillée de ce tutoriel, avec plus d’explications sur chaque étape, veuillez vous référer à Comment installer Linux, Nginx, MySQL, PHP (pile LEMP) sur Ubuntu 20.0

      Conditions préalables

      Pour suivre ce guide, vous devrez avoir accès à un serveur Ubuntu 20.04 en tant qu’utilisateur sudo.

      Étape 1 – Installation de Nginx

      Mettez à jour le cache de votre gestionnaire de packages et installez ensuite Nginx avec :

      • sudo apt update
      • sudo apt install nginx

      Une fois l’installation terminée, vous devrez ajuster les paramètres de votre pare-feu pour autoriser le trafic HTTP sur votre serveur. Exécutez la commande suivante pour autoriser l’accès externe sur le port 80 (HTTP) :

      • sudo ufw allow in "Nginx"

      Avec l’ajout de la nouvelle règle de pare-feu, vous pouvez vérifier si le serveur est opérationnel en accédant à l’adresse IP publique ou au nom de domaine de votre serveur depuis votre navigateur web. Vous verrez une page comme celle-ci :

      Page par défaut de Nginx

      Étape 2 – Installer MySQL

      Nous allons maintenant installer MySQL, un système de gestion de base de données populaire utilisé dans les environnements PHP.

      Là encore, utilisez apt pour acquérir et installer ce logiciel :

      • sudo apt install mysql-server

      Une fois l’installation terminée, il est recommandé d’exécuter un script de sécurité qui vient préinstallé avec MySQL. Lancez le script interactif en exécutant :

      • sudo mysql_secure_installation

      Il vous sera demandé si vous souhaitez configurer le VALIDATE PASSWORD PLUGIN. Répondez Y pour oui, ou tout autre chose pour continuer sans activer. Si vous répondez « oui », il vous sera demandé de choisir un niveau de validation du mot de passe.

      Votre serveur vous demandera ensuite de sélectionner et de confirmer un mot de passe pour l’utilisateur root de MySQL. Même si la méthode d’authentification par défaut pour l’utilisateur root de MySQL dispense de l’utilisation d’un mot de passe, même si celui-ci est défini, vous devez définir ici un mot de passe fort pour plus de sécurité.

      Pour le reste des questions, appuyez sur Y et appuyez sur la touche ENTRÉE à chaque invite.

      Note : Au moment de la rédaction de ce document, la bibliothèque MySQL PHP native mysqlnd ne prend pas en charge caching_sha2_authentification,la méthode d’authentification par défaut pour MySQL 8. Pour cette raison, lorsque vous créez des utilisateurs de base de données pour des applications PHP sur MySQL 8, vous devez vous assurer qu’ils sont configurés pour utiliser le mot de passe mysql_native_password à la place. Veuillez vous référer à l’étape 6 de notre guide détaillé LEMP sur Ubuntu 20.04 pour apprendre comment le faire.

      Étape 3 – Installer PHP

      Pour installer les packages php-fpm et php-mysql, exécutez :

      • sudo apt install php-fpm php-mysql

      Étape 4 – Configuration de Nginx pour PHP

      Dans ce guide, nous allons mettre en place un domaine appelé your_domain, mais vous devez le remplacer par votre propre nom de domaine. 

      Sur Ubuntu 20.04, Nginx dispose d’un bloc serveur activé par défaut qui est configuré pour servir des documents à partir d’un répertoire à /var/www/html. Même si cela fonctionne bien pour un seul site, cela peut devenir difficile à gérer si vous hébergez plusieurs sites. Au lieu de modifier /var/www/html, nous allons créer une structure de répertoire au sein de /var/www pour le site Web your_domain, en laissant /var/www/html en place comme répertoire par défaut à servir si une demande du client ne correspond à aucun autre site.

      Créez le répertoire racine Web pour your_domain comme suit :

      • sudo mkdir /var/www/your_domain

      Ensuite, attribuez la propriété du répertoire avec la variable d’environnement $USER qui fera référence à votre utilisateur actuel du système :

      • sudo chown -R $USER:$USER /var/www/your_domain

      Ouvrez ensuite un nouveau fichier de configuration dans le répertoire sites-available de Nginx en utilisant votre éditeur de ligne de commande préféré. Ici, nous utiliserons nano :

      • sudo nano /etc/nginx/sites-available/your_domain

      Cela créera un nouveau fichier vierge. Collez dans la configuration suivante :

      /etc/nginx/sites-available/your_domain

      server {
          listen 80;
          server_name your_domain www.your_domain;
          root /var/www/your_domain;
      
          index index.html index.htm index.php;
      
          location / {
              try_files $uri $uri/ =404;
          }
      
          location ~ .php$ {
              include snippets/fastcgi-php.conf;
              fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
           }
      
          location ~ /.ht {
              deny all;
          }
      
      }
      
      
      

      Une fois que vous avez terminé vos modifications, enregistrez et fermez le fichier. Si vous utilisez nano, vous pouvez le faire en appuyant sur CTRL + X, puis y et ENTER pour confirmer.

      Activez votre configuration en établissant un lien vers le fichier de configuration à partir du répertoire sites-enabled de Nginx :

      • sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/

      Cela indiquera à Nginx d’utiliser la configuration lors du prochain rechargement. Vous pouvez vérifier si votre configuration contient des fautes de syntaxe en tapant :

      Si des erreurs sont signalées, revenez à votre fichier de configuration pour corriger son contenu avant de continuer.

      Une fois que vous êtes prêt, rechargez Nginx pour appliquer les modifications :

      • sudo systemctl reload nginx

      Votre nouveau site web est maintenant actif, mais le root web /var/www/your_domain est toujours vide. Créez un fichier index.html à cet endroit afin que nous puissions tester si le bloc de serveur fonctionne comme prévu :

      • nano /var/www/your_domain/index.html

      Incluez le contenu suivant dans ce dossier :

      /var/www/your_domain/index.html

      <html>
        <head>
          <title>your_domain website</title>
        </head>
        <body>
          <h1>Hello World!</h1>
      
          <p>This is the landing page of <strong>your_domain</strong>.</p>
        </body>
      </html>
      

      Maintenant, allez dans votre navigateur et accédez au nom de domaine ou à l’adresse IP de votre serveur, comme indiqué dans la directive server_name de votre fichier de configuration de bloc de serveur :

      http://server_domain_or_IP
      

      Vous verrez une page comme celle-ci :

      Nginx server block

      Étape 5 – Test de PHP avec Nginx

      Nous allons maintenant créer un script de test PHP pour confirmer que Nginx est capable de gérer et de traiter les demandes de fichiers PHP.

      Créer un nouveau fichier nommé info.php à l’intérieur de votre dossier root web personnalisé : 

      • nano /var/www/your_domain/info.php

      Cela ouvrira un fichier vierge. Ajoutez le contenu suivant dans le fichier :

      /var/www/your_domain/info.php

      <?php
      phpinfo();
      

      Lorsque vous avez terminé, enregistrez et fermez le fichier.

      Vous pouvez maintenant accéder à cette page dans votre navigateur Web en consultant le nom de domaine ou l’adresse IP publique que vous avez défini dans votre fichier de configuration Nginx, suivi de /info.php :

      http://server_domain_or_IP/info.php
      

      Vous verrez apparaître une page Web contenant des informations détaillées sur votre serveur :

      PHPInfo Ubuntu 20.04

      Après avoir vérifié les informations pertinentes sur votre serveur PHP par le biais de cette page, il est préférable de supprimer le fichier que vous avez créé car il contient des informations sensibles sur votre environnement PHP et votre serveur Ubuntu. Vous pouvez utiliser rm pour supprimer ce fichier :

      • sudo rm /var/www/your_domain/info.php

      Tutoriels connexes

      Voici des liens vers des guides plus détaillés relatifs à ce tutoriel :



      Source link