One place for hosting & domains

      How To Deploy a React Application with Nginx on Ubuntu 20.04


      The author selected Creative Commons to receive a donation as part of the Write for DOnations program.

      Introduction

      You can quickly deploy React applications to a server using the default Create React App build tool. The build script compiles the application into a single directory containing all of the JavaScript code, images, styles, and HTML files. With the assets in a single location, you can deploy to a web server with minimal configuration.

      In this tutorial, you’ll deploy a React application on your local machine to an Ubuntu 20.04 server running Nginx. You’ll build an application using Create React App, use an Nginx config file to determine where to deploy files, and securely copy the build directory and its contents to the server. By the end of this tutorial, you’ll be able to build and deploy a React application.

      Prerequisites

      • On your local machine, you will need a development environment running Node.js; this tutorial was tested on Node.js version 10.22.0 and npm version 6.14.6. To install this on macOS or Ubuntu 20.04, follow the steps in How to Install Node.js and Create a Local Development Environment on macOS or the Installing Using a PPA section of How To Install Node.js on Ubuntu 20.04.

      • One Ubuntu 20.04 server for deployment, set up by following this initial server setup for Ubuntu 20.04 tutorial, including a sudo-enabled non-root user, a firewall, and SSH access from your local machine. To gain SSH access on a DigitalOcean Droplet, read through How to Connect to Droplets with SSH.

      • A registered domain name. This tutorial will use your_domain throughout. You can purchase a domain name from Namecheap, get one for free with Freenom, or use the domain registrar of your choice.

      • Both of the following DNS records set up for your server. If you are using DigitalOcean, please see our DNS documentation for details on how to add them.

        • An A record with your_domain pointing to your server’s public IP address.
        • An A record with www.your_domain pointing to your server’s public IP address.
      • Nginx installed by following How To Install Nginx on Ubuntu 20.04. Be sure that you have a server block for your domain. This tutorial will use /etc/nginx/sites-available/your_domain as an example.

      • It is recommended that you also secure your server with an HTTPS certificate. You can do this with the How To Secure Nginx with Let’s Encrypt on Ubuntu 20.04 tutorial.

      • You will also need a basic knowledge of JavaScript, HTML, and CSS, which you can find in our How To Build a Website With HTML series, How To Build a Website With CSS series, and in How To Code in JavaScript.

      Step 1 — Creating a React Project

      In this step, you’ll create an application using Create React App and build a deployable version of the boilerplate app.

      To start, create a new application using Create React App in your local environment. In a terminal, run the command to build an application. In this tutorial, the project will be called react-deploy:

      • npx create-react-app react-deploy

      The npx command will run a Node package without downloading it to your machine. The create-react-app script will install all of the dependencies needed for your React app and will build a base project in the react-deploy directory. For more on Create React App, check out out the tutorial How To Set Up a React Project with Create React App.

      The code will run for a few minutes as it downloads and installs the dependencies. When it is complete, you will receive a success message. Your version may be slightly different if you use yarn instead of npm:

      Output

      Success! Created react-deploy at your_file_path/react-deploy Inside that directory, you can run several commands: npm start Starts the development server. npm build Bundles the app into static files for production. npm test Starts the test runner. npm eject Removes this tool and copies build dependencies, configuration files and scripts into the app directory. If you do this, you can’t go back! We suggest that you begin by typing: cd react-deploy npm start Happy hacking!

      Following the suggestion in the output, first move into the project folder:

      Now that you have a base project, run it locally to test how it will appear on the server. Run the project using the npm start script:

      When the command runs, you’ll receive output with the local server info:

      Output

      Compiled successfully! You can now view react-deploy in the browser. Local: http://localhost:3000 On Your Network: http://192.168.1.110:3000 Note that the development build is not optimized. To create a production build, use npm build.

      Open a browser and navigate to http://localhost:3000. You will be able to access the boilerplate React app:

      React project template running locally

      Stop the project by entering either CTRL+C or ⌘+C in a terminal.

      Now that you have a project that runs successfully in a browser, you need to create a production build. Run the create-react-app build script with the following:

      This command will compile the JavaScript and assets into the build directory. When the command finishes, you will receive some output with data about your build. Notice that the filenames include a hash, so your output will be slightly different:

      Output

      Creating an optimized production build... Compiled successfully. File sizes after gzip: 41.21 KB build/static/js/2.82f639e7.chunk.js 1.4 KB build/static/js/3.9fbaa076.chunk.js 1.17 KB build/static/js/runtime-main.1caef30b.js 593 B build/static/js/main.e8c17c7d.chunk.js 546 B build/static/css/main.ab7136cd.chunk.css The project was built assuming it is hosted at /. You can control this with the homepage field in your package.json. The build folder is ready to be deployed. You may serve it with a static server: serve -s build Find out more about deployment here: https://cra.link/deployment

      The build directory will now include compiled and minified versions of all the files you need for your project. At this point, you don’t need to worry about anything outside of the build directory. All you need to do is deploy the directory to a server.

      In this step, you created a new React application. You verified that the application runs locally and you built a production version using the Create React App build script. In the next step, you’ll log onto your server to learn where to copy the build directory.

      Step 2 — Determining Deployment File Location on your Ubuntu Server

      In this step, you’ll start to deploy your React application to a server. But before you can upload the files, you’ll need to determine the correct file location on your deployment server. This tutorial uses Nginx as a web server, but the approach is the same with Apache. The main difference is that the configuration files will be in a different directory.

      To find the directory the web server will use as the root for your project, log in to your server using ssh:

      Once on the server, look for your web server configuration in /etc/nginx/sites-enabled. There is also a directory called sites-allowed; this directory includes configurations that are not necessarily activated. Once you find the configuration file, display the output in your terminal with the following command:

      • cat /etc/nginx/sites-enabled/your_domain

      If your site has no HTTPS certificate, you will receive a result similar to this:

      Output

      server { listen 80; listen [::]:80; root /var/www/your_domain/html; index index.html index.htm index.nginx-debian.html; server_name your_domain www.your_domain; location / { try_files $uri $uri/ =404; } }

      If you followed the Let’s Encrypt prerequisite to secure your Ubuntu 20.04 server, you will receive this output:

      Output

      server { root /var/www/your_domain/html; index index.html index.htm index.nginx-debian.html; server_name your_domain www.your_domain; location / { try_files $uri $uri/ =404; } listen [::]:443 ssl ipv6only=on; # managed by Certbot listen 443 ssl; # managed by Certbot ssl_certificate /etc/letsencrypt/live/your_domain/fullchain.pem; # managed by Certbot ssl_certificate_key /etc/letsencrypt/live/your_domain/privkey.pem; # managed by Certbot include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot } server { if ($host = www.your_domain) { return 301 https://$host$request_uri; } # managed by Certbot if ($host = your_domain) { return 301 https://$host$request_uri; } # managed by Certbot listen 80; listen [::]:80; server_name your_domain www.your_domain; return 404; # managed by Certbot }

      In either case, the most important field for deploying your React app is root. This points HTTP requests to the /var/www/your_domain/html directory. That means you will copy your files to that location. In the next line, you can see that Nginx will look for an index.html file. If you look in your local build directory, you will see an index.html file that will serve as the main entry point.

      Log off the Ubuntu 20.04 server and go back to your local development environment.

      Now that you know the file location that Nginx will serve, you can upload your build.

      Step 3 — Uploading Build Files with scp

      At this point, your build files are ready to go. All you need to do is copy them to the server. A quick way to do this is to use scp to copy your files to the correct location. The scp command is a secure way to copy files to a remote server from a terminal. The command uses your ssh key if it is configured. Otherwise, you will be prompted for a username and password.

      The command format will be scp files_to_copy username@server_ip:path_on_server. The first argument will be the files you want to copy. In this case, you are copying all of the files in the build directory. The second argument is a combination of your credentials and the destination path. The destination path will be the same as the root in your Nginx config:/var/www/your_domain/html.

      Copy all the build files using the * wildcard to /var/www/your_domain/html:

      • scp -r ./build/* username@server_ip:/var/www/your_domain/html

      When you run the command, you will receive output showing that your files are uploaded. Your results will be slightly different:

      Output

      asset-manifest.json 100% 1092 22.0KB/s 00:00 favicon.ico 100% 3870 80.5KB/s 00:00 index.html 100% 3032 61.1KB/s 00:00 logo192.png 100% 5347 59.9KB/s 00:00 logo512.png 100% 9664 69.5KB/s 00:00 manifest.json 100% 492 10.4KB/s 00:00 robots.txt 100% 67 1.0KB/s 00:00 main.ab7136cd.chunk.css 100% 943 20.8KB/s 00:00 main.ab7136cd.chunk.css.map 100% 1490 31.2KB/s 00:00 runtime-main.1caef30b.js.map 100% 12KB 90.3KB/s 00:00 3.9fbaa076.chunk.js 100% 3561 67.2KB/s 00:00 2.82f639e7.chunk.js.map 100% 313KB 156.1KB/s 00:02 runtime-main.1caef30b.js 100% 2372 45.8KB/s 00:00 main.e8c17c7d.chunk.js.map 100% 2436 50.9KB/s 00:00 3.9fbaa076.chunk.js.map 100% 7690 146.7KB/s 00:00 2.82f639e7.chunk.js 100% 128KB 226.5KB/s 00:00 2.82f639e7.chunk.js.LICENSE.txt 100% 1043 21.6KB/s 00:00 main.e8c17c7d.chunk.js 100% 1045 21.7KB/s 00:00 logo.103b5fa1.svg 100% 2671 56.8KB/s 00:00

      When the command completes, you are finished. Since a React project is built of static files that only need a browser, you don’t have to configure any further server-side language. Open a browser and navigate to your domain name. When you do, you will find your React project:

      Browser with React Project on Server

      In this step, you deployed a React application to a server. You learned how to identify the root web directory on your server and you copied the files with scp. When the files finished uploading, you were able to view your project in a web browser.

      Conclusion

      Deploying React applications is a quick process when you use Create React App. You run the build command to create a directory of all the files you need for a deployment. After running the build, you copy the files to the correct location on the server, pushing your application live to the web.

      If you would like to read more React tutorials, check out our React Topic page, or return to the How To Code in React.js series page.



      Source link

      How To Secure Nginx with Let’s Encrypt on CentOS 8


      Not using CentOS 8?


      Choose a different version or distribution.

      The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Let’s Encrypt is a certificate authority (CA) that provides free certificates for Transport Layer Security (TLS) encryption. It simplifies the process of creation, validation, signing, installation, and renewal of certificates by providing a software client—Certbot.

      In this tutorial you’ll set up a TLS/SSL certificate from Let’s Encrypt on a CentOS 8 server running Nginx as a web server. Additionally, you will automate the certificate renewal process using a cron job.

      Prerequisites

      In order to complete this guide, you will need:

      • One CentOS 8 server set up by following the CentOS 8 Initial Server Setup guide, including a non-root user with sudo privileges and a firewall.
      • Nginx installed on the CentOS 8 server with a configured server block. You can learn how to set this up by following our tutorial How To Install Nginx on CentOS 8.
      • A fully registered domain name. This tutorial will use your_domain as an example throughout. You can purchase a domain name on Namecheap, get one for free on Freenom, or use the domain registrar of your choice.
      • Both of the following DNS records set up for your server. You can follow this introduction to DigitalOcean DNS for details on how to add them.
        • An A record with your_domain pointing to your server’s public IP address.
        • An A record with www.your_domain pointing to your server’s public IP address.

      Step 1 — Installing the Certbot Let’s Encrypt Client

      First, you need to install the certbot software package. Log in to your CentOS 8 machine as your non-root user:

      The certbot package is not available through the package manager by default. You will need to enable the EPEL repository to install Certbot.

      To add the CentOS 8 EPEL repository, run the following command:

      • sudo dnf install epel-release

      When asked to confirm the installation, type and enter y.

      Now that you have access to the extra repository, install all of the required packages:

      • sudo dnf install certbot python3-certbot-nginx

      This will install Certbot itself and the Nginx plugin for Certbot, which is needed to run the program.

      The installation process will ask you about importing a GPG key. Confirm it so the installation can complete.

      You have now installed the Let’s Encrypt client, but before obtaining certificates, you need to make sure that all required ports are open. To do this, you will update your firewall settings in the next step.

      Step 2 — Updating the Firewall Rules

      Since your prerequisite setup enables firewalld, you will need to adjust the firewall settings in order to allow external connections on your Nginx web server.

      To check which services are already enabled, run the command:

      • sudo firewall-cmd --permanent --list-all

      You’ll receive output like this:

      Output

      public target: default icmp-block-inversion: no interfaces: sources: services: cockpit dhcpv6-client http ssh ports: protocols: masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:

      If you do not see http in the services list, enable it by running:

      • sudo firewall-cmd --permanent --add-service=http

      To allow https traffic, run the following command:

      • sudo firewall-cmd --permanent --add-service=https

      To apply the changes, you’ll need to reload the firewall service:

      • sudo firewall-cmd --reload

      Now that you’ve opened up your server to https traffic, you’re ready to run Certbot and fetch your certificates.

      Step 3 — Obtaining a Certificate

      Now you can request an SSL certificate for your domain.

      When generating the SSL Certificate for Nginx using the certbot Let’s Encrypt client, the client will automatically obtain and install a new SSL certificate that is valid for the domains provided as parameters.

      If you want to install a single certificate that is valid for multiple domains or subdomains, you can pass them as additional parameters to the command. The first domain name in the list of parameters will be the base domain used by Let’s Encrypt to create the certificate, and for that reason you will pass the top-level domain name as first in the list, followed by any additional subdomains or aliases:

      • sudo certbot --nginx -d your_domain -d www.your_domain

      This runs certbot with the --nginx plugin, and the base domain will be your_domain. To execute the interactive installation and obtain a certificate that covers only a single domain, run the certbot command with:

      • sudo certbot --nginx -d your_domain

      The certbot utility can also prompt you for domain information during the certificate request procedure. To use this functionality, call certbot without any domains:

      You will receive a step-by-step guide to customize your certificate options. Certbot will ask you to provide an email address for lost key recovery and notices and to agree to the terms of service. If you did not specify your domains on the command line, Certbot will look for a server_name directive and will give you a list of the domain names found. If your server block files do not specify the domain they serve explicitly using the server_name directive, Certbot will ask you to provide domain names manually.

      For better security, Certbot will automatically configure redirecting all traffic on port 80 to 443.

      When the installation successfully finishes, you will receive a message similar to this:

      Output

      IMPORTANT NOTES: - Congratulations! Your certificate and chain have been saved at: /etc/letsencrypt/live/your_domain/fullchain.pem Your key file has been saved at: /etc/letsencrypt/live/your_domain/privkey.pem Your cert will expire on 2021-02-26. To obtain a new or tweaked version of this certificate in the future, simply run certbot again with the "certonly" option. To non-interactively renew *all* of your certificates, run "certbot renew" - If you like Certbot, please consider supporting our work by: Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate Donating to EFF: https://eff.org/donate-le

      The generated certificate files will be available within a subdirectory named after your base domain in the /etc/letsencrypt/live directory.

      Now that you have finished using Certbot, you can check your SSL certificate status. Verify the status of your SSL certificate by opening the following link in your preferred web browser (don’t forget to replace your_domain with your base domain):

      https://www.ssllabs.com/ssltest/analyze.html?d=your_domain
      

      This site contains an SSL test from SSL Labs, which will start automatically. At the time of this writing, default settings will give an A rating.

      You can now access your website using the https prefix. However, you must renew certificates periodically to keep this setup working. In the next step, you will automate this renewal process.

      Step 4 — Setting Up Auto-Renewal

      Let’s Encrypt certificates are valid for 90 days, but it’s recommended that you renew the certificates every 60 days to allow for a margin of error. The Certbot Let’s Encrypt client has a renew command that automatically checks the currently installed certificates and tries to renew them if they are less than 30 days away from the expiration date.

      You can test automatic renewal for your certificates by running this command:

      • sudo certbot renew --dry-run

      The output will be similar to this:

      Output

      Saving debug log to /var/log/letsencrypt/letsencrypt.log - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Processing /etc/letsencrypt/renewal/your_domain.conf - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Cert not due for renewal, but simulating renewal for dry run Plugins selected: Authenticator nginx, Installer nginx Renewing an existing certificate Performing the following challenges: http-01 challenge for monitoring.pp.ua Waiting for verification... Cleaning up challenges - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - new certificate deployed with reload of nginx server; fullchain is /etc/letsencrypt/live/your_domain/fullchain.pem - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ** DRY RUN: simulating 'certbot renew' close to cert expiry ** (The test certificates below have not been saved.) Congratulations, all renewals succeeded. The following certs have been renewed: /etc/letsencrypt/live/your_domain/fullchain.pem (success) ...

      Notice that if you created a bundled certificate with multiple domains, only the base domain name will show in the output, but the renewal will work for all domains included in this certificate.

      A practical way to ensure your certificates will not get outdated is to create a cron job that will periodically execute the automatic renewal command for you. Since the renewal first checks for the expiration date and only executes the renewal if the certificate is less than 30 days away from expiration, it is safe to create a cron job that runs every week, or even every day.

      Edit the crontab to create a new job that will run the renewal twice per day. To edit the crontab for the root user, run:

      Your text editor will open the default crontab, which is an empty text file at this point. Enter insert mode by pressing i and add in the following line:

      crontab

      0 0,12 * * * python -c 'import random; import time; time.sleep(random.random() * 3600)' && certbot renew --quiet
      

      When you’re finished, press ESC to leave insert mode, then :wq and ENTER to save and exit the file. To learn more about the text editor Vi and its successor Vim, check out our Installing and Using the Vim Text Editor on a Cloud Server tutorial.

      This will create a new cron job that will execute at noon and midnight every day. python -c 'import random; import time; time.sleep(random.random() * 3600)' will select a random minute within the hour for your renewal tasks.

      The renew command for Certbot will check all certificates installed on the system and update any that are set to expire in less than thirty days. --quiet tells Certbot not to output information or wait for user input.

      More detailed information about renewal can be found in the Certbot documentation.

      Conclusion

      In this guide, you installed the Let’s Encrypt client Certbot, downloaded SSL certificates for your domain, and set up automatic certificate renewal. If you have any questions about using Certbot, you can check the official Certbot documentation.

      You can also check the official Let’s Encrypt blog for important updates from time to time.



      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