One place for hosting & domains

      What is Redis?


      Redis is an open-source key-value data store known for its flexibility, performance, and wide language support. An in-memory database, Redis is also known for its speed and has found wide use as a cache and message broker, as well as a database.

      A NoSQL database, Redis doesn’t use structured query language, otherwise known as SQL. Redis instead comes with its own set of commands for managing and accessing data.

      To learn more about Redis, please visit:

      A complete list of our educational resources on Redis can be found on our Redis tag page.



      Source link

      How To Set Up Redis as a Cache for MySQL with PHP on Ubuntu 20.04


      The author selected Girls Who Code to receive a donation as part of the Write for DOnations program.

      Introduction

      Redis (Remote Dictionary Server) is a fast open-source, in-memory database that you can use as a key-value store for a highly scalable and performance-oriented system. Some of Redis’ use cases include: caching, high-speed transactions, real-time analytics, live notifications, machine learning, searching, and queue/job processing. Since Redis is an in-memory key-value store, its performance makes it suitable for caching data in your application.

      Caching is storing data temporarily in a high-speed storage layer (for example, in a computer RAM) to serve data faster when clients make the same future requests. This enhances the re-use of previously computed data instead of fetching it each time from the disk.

      When you’re working with PHP and MySQL, using Redis as a cache improves your application performance because Redis stores data in RAM, which is several times faster than a hard disk (HDD) or a solid-state drive (SSD). Caching also reduces database costs—that is, the number of round trips made to the back-end database—and avoids overloading the backend.

      Caching data is an integral design feature when you’re designing web applications with higher reads than writes. Such applications include blogs, online stores, and social media sites.

      In this tutorial, you’ll use Redis to cache MySQL data with PHP on Ubuntu 20.04.

      Prerequisites

      To complete this tutorial, you’ll need the following:

      Step 1 — Installing the Redis Library for PHP

      To begin you’ll install the php-redis extension, which will allow you to use PHP to communicate with Redis. Run the following commands to update your server and install the extension:

      • sudo apt update
      • sudo apt install php-redis

      Confirm the installation and restart the Apache web server to load the extension:

      • sudo systemctl restart apache2

      Now that you have installed your dependencies, you’ll set up your database.

      Step 2 — Setting Up a Test Database, Table, and Sample Data

      In this step, you’ll create a MySQL database to store data permanently to disk. You’ll also create some tables and a user account with full privileges to the database.

      First, log in to your MySQL server as a root user:

      Enter the root password of your MySQL server that you set up in the LAMP prerequisite. Then, press ENTER to continue.

      Next, create a test_store database with the following command:

      • CREATE database test_store;

      Make sure the action is successful by confirming the output:

      Output

      Query OK, 1 row affected (0.00 sec)

      Next, create a user for your database. We’ll call this user test_user in this tutorial. Replace PASSWORD with a strong password as well:

      • CREATE USER 'test_user'@'localhost' IDENTIFIED WITH mysql_native_password BY 'PASSWORD';

      Then grant test_user full privileges to the test_store database with:

      • GRANT ALL PRIVILEGES ON test_store.* TO 'test_user'@'localhost';

      Finally run the following command to reload the grant tables in MySQL:

      Ensure you get the following output after each successful command:

      Output

      Query OK, 0 rows affected (0.01 sec)

      End the MySQL root session:

      You’ll receive the word Bye and the system will take you back to the server’s command line interface.

      Log back in to the MySQL server with the credentials for the test_user that you just created:

      Enter the password for the test_user to proceed. Then, switch to the test_store database when you’re in the mysql> prompt:

      Ensure you receive the following output:

      Output

      Database Changed.

      Next, you’ll create a products table with three columns. You’ll use the product_id column to uniquely identify each product. To avoid assigning the IDs manually, you’ll use the AUTO_INCREMENT keyword. Then, you’ll use the BIGINT data type for the product_id column to support a large data set. The BIGINT data type can hold a minimum value of -2^63 and a maximum value of 2^63 - 1.

      The product_name field will hold the actual names of your items. In this case, a VARCHAR data type with a length of 50 characters will be enough. The last column in the products table is the price—you’ll use the DOUBLE data type to accommodate prices with decimals (for example, 16.33).

      To create the products table, run the following command:

      • CREATE table products
      • (
      • product_id BIGINT PRIMARY KEY AUTO_INCREMENT,
      • product_name VARCHAR(50),
      • price DOUBLE
      • ) Engine = InnoDB;

      You will receive the following output:

      Output

      Query OK, 0 rows affected (0.01 sec)

      Now you’ll populate the products table with some records for testing purposes.

      You don’t need to enter data to the product_id column manually since the AUTO_INCREMENT column will complete this. Run the following commands one by one:

      • INSERT INTO products(product_name, price) VALUES ('Virtual Private Servers', '5.00');
      • INSERT INTO products(product_name, price) VALUES ('Managed Databases', '15.00');
      • INSERT INTO products(product_name, price) VALUES ('Block Storage', '10.00');
      • INSERT INTO products(product_name, price) VALUES ('Managed Kubernetes', '60.00');
      • INSERT INTO products(product_name, price) VALUES ('Load Balancer', '10.00');

      After running each command, ensure you get this output:

      Output

      Query OK, 1 row affected (0.00 sec)

      Verify the data using the SELECT command:

      You will receive output similar to the following:

      Output

      +------------+-------------------------+-------+ | product_id | product_name | price | +------------+-------------------------+-------+ | 1 | Virtual Private Servers | 5 | | 2 | Managed Databases | 15 | | 3 | Block Storage | 10 | | 4 | Managed Kubernetes | 60 | | 5 | Load Balancer | 10 | +------------+-------------------------+-------+ 5 rows in set (0.00 sec)

      End the MySQL session for the test_user:

      Once you’ve set up the test_store database, products table, and test_user, you’ll code a PHP script to retrieve data from the MySQL database and cache it to Redis.

      Step 3 — Designing a PHP Script for Fetching and Caching MySQL Data

      In this step, you’ll create a PHP script for retrieving the sample data that you’ve created in the previous step.

      When you run the script for the first time, it will read the data from MySQL (that is, from disk) and then cache it to Redis. As a result subsequent reads of the products’ data will be from Redis (that is, from system RAM). System memory is multiple times faster than even the fastest solid-state drive, thus data will be retrieved faster from the Redis cache than reading from the system disk.

      Note: While you might not get any performance boost, since you are retrieving just a few records from the MySQL database, several benchmarks prove that retrieving cached data from Redis is several times faster than reading it from MySQL when dealing with several hundred thousand records.

      Create a products.php file in the root directory of your website:

      • sudo nano /var/www/html/products.php

      To start, enter the following information to connect and create an instance of Redis and store it as an object in a $redis variable.

      The address 127.0.0.1 connects to the localhost. You may change this value if you’re running Redis from a remote server. Remember to replace REDIS_PASSWORD with the specific password for Redis set in the /etc/redis/redis.conf configuration file.

      Also, enter the appropriate port number. By default, Redis runs on port 6379:

      /var/www/html/products.php

      <?php
      
      $redis = new Redis();
      $redis->connect('127.0.0.1', 6379);
      $redis->auth('REDIS_PASSWORD');
      

      Note: In this guide, the $redis->auth('REDIS_PASSWORD') command sends your password to Redis in plain text. In a production environment, you may consider securing end-to-end communication between Redis and the client server running PHP code with a more powerful access control layer, such as TLS (Transport Layer Security). Also, when configuring your Redis password in the /etc/redis/redis.conf file, make sure you set a long and strong value to prevent brute-force attacks.

      The next step is initializing a PHP variable you’ll use as a key in Redis.

      As mentioned earlier in this guide, Redis acts as a key-value database and therefore you must have a unique key for the data that you intend to store and retrieve from it.

      So, define a PRODUCTS key by adding the following information to the /var/www/html/products.php file. You are free to use any name in place of PRODUCTS key.

      Your PHP script will use this key to cache information to Redis once data gets retrieved from the MySQL database:

      /var/www/html/products.php

      ...
      $key = 'PRODUCTS';
      

      Next, include a conditional PHP if...else statement to check if the PRODUCTS key exists in Redis:

      /var/www/html/products.php

      ...
      if (!$redis->get($key)) {
          $source="MySQL Server";
          $database_name="test_store";
          $database_user="test_user";
          $database_password = 'PASSWORD';
          $mysql_host="localhost";
      
          $pdo = new PDO('mysql:host=" . $mysql_host . "; dbname=" . $database_name, $database_user, $database_password);
          $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      
          $sql  = "SELECT * FROM products";
          $stmt = $pdo->prepare($sql);
          $stmt->execute();
      
          while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
             $products[] = $row;
          }
      
          $redis->set($key, serialize($products));
          $redis->expire($key, 10);
      
      } else {
           $source = "Redis Server';
           $products = unserialize($redis->get($key));
      
      }
      
      echo $source . ': <br>';
      print_r($products);
      

      If the key doesn’t exist in Redis, the script connects to the database that you created earlier, queries the products table, and stores the data in Redis using the $redis->set($key, serialize($products)) command.

      The $redis->expire($key, 10); command sets the expiration to 10 seconds. You may tweak this value depending on your cache policy.

      The $source variable helps you to identify the source of the data once it is echoed as an array at the end of the script using the echo $source and print_r($products) commands.

      Once you’ve put everything together, your /var/www/html/products.php file will be as follows:

      /var/www/html/products.php

      <?php
      
      $redis = new Redis();
      $redis->connect('127.0.0.1', 6379);
      $redis->auth('REDIS_PASSWORD');
      
      $key = 'PRODUCTS';
      
      if (!$redis->get($key)) {
          $source="MySQL Server";
          $database_name="test_store";
          $database_user="test_user";
          $database_password = 'PASSWORD';
          $mysql_host="localhost";
      
          $pdo = new PDO('mysql:host=" . $mysql_host . "; dbname=" . $database_name, $database_user, $database_password);
          $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      
          $sql  = "SELECT * FROM products";
          $stmt = $pdo->prepare($sql);
          $stmt->execute();
      
          while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
             $products[] = $row;
          }
      
          $redis->set($key, serialize($products));
          $redis->expire($key, 10);
      
      } else {
           $source = "Redis Server';
           $products = unserialize($redis->get($key));
      
      }
      
      echo $source . ': <br>';
      print_r($products);
      
      

      Save and close the file.

      You’ve now set up a PHP script that will connect to MySQL and cache data to Redis. You’ll test your script in the next step.

      Step 4 — Testing the PHP Script

      To test if Redis is caching data from the MySQL database, you’ll enter the path of the PHP script in a browser window. Remember to replace your_server_IP with the public IP address of your server, like so: http://your_server_IP/products.php.

      When you run the script for the first time, you will receive the following output that displays data from the MySQL database because, at this point, the PHP script has not yet cached any data in Redis:

      MySQL Server
      Array ( [0] => Array ( [product_id] => 1 [product_name] => Virtual Private Servers [price] => 5 ) [1] => Array ( [product_id] => 2 [product_name] => Managed Databases [price] => 15 ) [2] => Array ( [product_id] => 3 [product_name] => Block Storage [price] => 10 ) [3] => Array ( [product_id] => 4 [product_name] => Managed Kubernetes [price] => 60 ) [4] => Array ( [product_id] => 5 [product_name] => Load Balancer [price] => 10 ) )
      

      Once you run the script again, you’ll get an output confirming that it’s reading data from Redis, which is acting as a cache for MySQL.

      Redis Server
      Array ( [0] => Array ( [product_id] => 1 [product_name] => Virtual Private Servers [price] => 5 ) [1] => Array ( [product_id] => 2 [product_name] => Managed Databases [price] => 15 ) [2] => Array ( [product_id] => 3 [product_name] => Block Storage [price] => 10 ) [3] => Array ( [product_id] => 4 [product_name] => Managed Kubernetes [price] => 60 ) [4] => Array ( [product_id] => 5 [product_name] => Load Balancer [price] => 10 ) )
      

      Remember that the key will expire after 10 seconds and data will again be retrieved from MySQL.

      Conclusion

      In this guide, you’ve used Redis to cache MySQL data with PHP on Ubuntu 20.04. You may use the coding in this guide to set up a caching mechanism for your MySQL data, which is especially useful for high-traffic web applications.

      You can check out our Redis topic page for more educational resources. Or, learn more about coding in PHP with further tutorials and content on the PHP topic page.



      Source link

      Cara Menginstal dan Mengamankan Redis pada Ubuntu 20.04


      Versi sebelumnya dari tutorial ini ditulis oleh Justin Ellingwood

      Pengantar

      Redis adalah penyimpanan nilai kunci dalam memori yang dikenal karena fleksibilitas, kinerja, dan dukungan bahasanya yang luas. Tutorial ini mendemonstrasikan cara menginstal, mengonfigurasi, dan mengamankan Redis pada server Ubuntu 20.04.

      Prasyarat

      Untuk menyelesaikan panduan ini, Anda akan memerlukan akses ke server Ubuntu 20.04 yang memiliki pengguna non-root dengan privilese sudo dan firewall yang terkonfigurasi dengan ufw. Anda dapat menyiapkan ini dengan mengikuti Panduan Penyiapan Server Awal untuk Ubuntu 20.04 dari kami.

      Langkah 1 — Menginstal dan Mengonfigurasi Redis

      Kita akan menggunakan manajer paket APT untuk menginstal redis dari repositori Ubuntu resmi. Pada saat penulisan panduan ini, versi yang tersedia dalam repositori asali adalah 5.0.7.

      Mulailah dengan memperbarui cache paket apt lokal Anda:

      Lalu instal Redis dengan mengetik:

      • sudo apt install redis-server

      Ini akan mengunduh dan menginstal Redis serta dependensinya. Setelah ini, ada satu perubahan konfigurasi penting yang harus dibuat di dalam berkas konfigurasi Redis, yang dihasilkan secara otomatis selama instalasi.

      Buka berkas ini dengan editor teks pilihan Anda:

      • sudo nano /etc/redis/redis.conf

      Di dalam berkas itu, temukan arahan supervised. Arahan ini memungkinkan Anda untuk mendeklarasikan sistem init untuk mengelola Redis sebagai suatu layanan, yang memberi Anda kontrol lebih atas operasinya. Arahan supervised diatur sebagai no secara asali. Karena Anda menjalankan Ubuntu, yang menggunakan sistem init systemd, ubah ini menjadi systemd:

      /etc/redis/redis.conf

      . . .
      
      # If you run Redis from upstart or systemd, Redis can interact with your
      # supervision tree. Options:
      #   supervised no      - no supervision interaction
      #   supervised upstart - signal upstart by putting Redis into SIGSTOP mode
      #   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
      #   supervised auto    - detect upstart or systemd method based on
      #                        UPSTART_JOB or NOTIFY_SOCKET environment variables
      # Note: these supervision methods only signal "process is ready."
      #       They do not enable continuous liveness pings back to your supervisor.
      supervised systemd
      
      . . .
      

      Itu adalah satu-satunya perubahan yang Anda perlu buat terhadap berkas konfigurasi Redis saat ini, jadi simpan dan tutup berkasnya ketika Anda selesai. Jika Anda menggunakan nano untuk mengedit berkas, lakukan itu dengan menekan CTRL + X, Y, lalu ENTER.

      Lalu, mulai ulang layanan Redis untuk mencerminkan perubahan yang Anda buat ke berkas konfigurasi:

      • sudo systemctl restart redis.service

      Dengan itu, Anda telah menginstal dan mengonfigurasi Redis dan Redis berjalan pada mesin Anda. Sebelum Anda mulai menggunakannya, merupakan hal bijaksana untuk memeriksa terlebih dahulu apakah Redis berfungsi dengan benar.

      Langkah 2 — Menguji Redis

      Seperti perangkat lunak yang baru terinstal lainnya, sebaiknya pastikan bahwa Redis berfungsi seperti yang diharapkan sebelum membuat perubahan apa pun terhadap konfigurasinya. Kita akan membahas beberapa cara untuk memeriksa bahwa Redis bekerja dengan benar dalam langkah ini.

      Mulai dengan memeriksa bahwa layanan Redis sedang berjalan:

      • sudo systemctl status redis

      Jika Redis berjalan tanpa kesalahan apa pun, perintah ini akan menghasilkan keluaran yang mirip dengan berikut ini:

      Output

      ● redis-server.service - Advanced key-value store Loaded: loaded (/lib/systemd/system/redis-server.service; enabled; vendor preset: enabled) Active: active (running) since Thu 2020-04-30 23:26:54 UTC; 4s ago Docs: http://redis.io/documentation, man:redis-server(1) Process: 36552 ExecStart=/usr/bin/redis-server /etc/redis/redis.conf (code=exited, status=0/SUCCESS) Main PID: 36561 (redis-server) Tasks: 4 (limit: 2345) Memory: 1.8M CGroup: /system.slice/redis-server.service └─36561 /usr/bin/redis-server 127.0.0.1:6379 . . .

      Di sini, Anda dapat melihat bahwa Redis sedang berjalan dan sudah diaktifkan, yang berarti bahwa sistem sudah disiapkan untuk memulai setiap kali server melakukan boot.

      Catatan: Pengaturan ini diinginkan untuk banyak kasus penggunaan umum dari Redis. Namun, jika Anda lebih memilih untuk memulai Redis secara manual setiap kali server melakukan boot, Anda dapat mengonfigurasi ini dengan perintah berikut:

      • sudo systemctl disable redis

      Untuk menguji bahwa Redis berfungsi dengan benar, hubungkan ke server menggunakan redis-cli, yang merupakan klien baris perintah Redis:

      Dalam prompt selanjutnya, uji konektivitas dengan perintah ping:

      Output

      PONG

      Keluaran ini mengonfirmasi bahwa koneksi server masih hidup. Selanjutnya, periksa apakah Anda dapat mengatur kunci dengan menjalankan:

      Output

      OK

      Dapatkan nilainya dengan mengetik:

      Dengan asumsi semuanya berjalan lancar, Anda akan dapat mendapatkan nilai yang Anda simpan:

      Output

      "It's working!"

      Setelah mengonfirmasi bahwa Anda dapat mengambil nilai, keluarlah dari prompt Redis untuk kembali ke shell:

      Sebagai uji coba terakhir, kita akan memeriksa apakah Redis dapat mempertahankan data bahkan setelah sistem dihentikan atau dimulai kembali. Untuk melakukan ini, pertama-tama mulai ulang instans Redis:

      • sudo systemctl restart redis

      Lalu, hubungkan dengan klien baris perintah lagi:

      Dan konfirmasikan bahwa nilai uji coba Anda masih ada

      Nilai dari kunci Anda harus masih dapat diakses:

      Output

      "It's working!"

      Keluarlah dari shell lagi ketika Anda selesai:

      Dengan itu, instalasi Redis Anda sudah beroperasi sepenuhnya dan siap untuk digunakan. Namun, beberapa pengaturan konfigurasi asalinya tidak aman dan memberi peluang kepada aktor jahat untuk menyerang dan memperoleh akses ke server dan data Anda. Langkah-langkah selanjutnya dalam tutorial ini mencakup metode untuk mengurangi kerentanan ini, seperti yang disarankan oleh situs web Redis resmi. Meskipun langkah-langkah ini bersifat opsional dan Redis tetap akan berfungsi jika Anda memilih untuk tidak mengikutinya, tetapi Anda sangat disarankan untuk menyelesaikannya untuk memperkuat keamanan sistem Anda.

      Langkah 3 — Mengikat ke localhost

      Secara asali, Redis hanya dapat diakses dari localhost. Namun, jika Anda menginstal dan mengonfigurasi Redis dengan mengikuti tutorial yang berbeda dari tutorial ini, Anda mungkin telah memperbarui berkas konfigurasi untuk mengizinkan koneksi dari mana saja. Ini tidak seaman terikat ke localhost.

      Untuk memperbaiki ini, buka berkas konfigurasi Redis untuk mengedit:

      • sudo nano /etc/redis/redis.conf

      Temukan baris ini dan pastikan bahwa baris ini tidak dijadikan komentar (hapus # jika ada):

      /etc/redis/redis.conf

      bind 127.0.0.1 ::1
      

      Simpan dan tutup berkas saat selesai (tekan CTRL + X, Y, lalu ENTER).

      Lalu, mulai ulang layanan untuk memastikan bahwa systemd membaca perubahan Anda:

      • sudo systemctl restart redis

      Untuk memeriksa bahwa perubahan ini telah diterapkan, jalankan perintah netstat berikut:

      • sudo netstat -lnp | grep redis

      Output

      tcp 0 0 127.0.0.1:6379 0.0.0.0:* LISTEN 14222/redis-server tcp6 0 0 ::1:6379 :::* LISTEN 14222/redis-server

      Catatan: Perintah netstat mungkin tidak tersedia di sistem Anda secara asali. Jika kasusnya seperti ini, Anda dapat menginstalnya (bersama dengan beberapa peralatan jejaring berguna lainnya) dengan perintah berikut :

      • sudo apt install net-tools

      Keluaran ini menunjukkan bahwa program redis-server terikat ke localhost (127.0.0.1), yang mencerminkan perubahan yang Anda baru saja buat pada berkas konfigurasi. Jika Anda melihat alamat IP lain di dalam kolom itu (sebagai contoh: 0.0.0.0), maka Anda harus memeriksa ulang bahwa Anda telah menghapus tanda komentar pada baris yang benar dan memulai ulang layanan Redis lagi.

      Kini setelah instalasi Redis Anda hanya mendengarkan localhost, maka akan lebih sulit bagi aktor jahat untuk membuat permintaan atau memperoleh akses ke server Anda. Namun, Redis saat ini tidak diatur untuk meminta pengguna melakukan autentikasi sendiri sebelum membuat perubahan ke konfigurasi atau data yang dimilikinya. Untuk memperbaiki ini, Redis mengizinkan Anda untuk meminta pengguna melakukan autentikasi dengan kata sandi sebelum membuat perubahan melalui klien Redis (redis-cli).

      Langkah 4 — Mengonfigurasi Kata sandi Redis

      Mengonfigurasi kata sandi Redis akan mengaktifkan salah satu dari dua fitur keamanan bawaan — perintah auth, yang mengharuskan klien melakukan autentikasi untuk mengakses basis data. Kata sandi dikonfigurasi secara langsung di dalam berkas konfigurasi Redis, /etc/redis/redis.conf, jadi buka berkas itu lagi dengan editor pilihan Anda:

      • sudo nano /etc/redis/redis.conf

      Gulir ke bagian SECURITY dan cari arahan dengan komentar yang berbunyi:

      /etc/redis/redis.conf

      . . .
      # requirepass foobared
      . . .
      

      Hapus status komentar dengan menghapus #, dan ubah foobared menjadi kata sandi yang aman.

      Catatan: Di atas arahan requirepass di dalam berkas redis.conf, ada peringatan dengan komentar:

      /etc/redis/redis.conf

      . . .
      # Warning: since Redis is pretty fast an outside user can try up to
      # 150k passwords per second against a good box. This means that you should
      # use a very strong password otherwise it will be very easy to break.
      #
      . . .
      

      Maka dari itu, merupakan hal penting bagi Anda untuk menentukan nilai yang sangat kuat dan sangat panjang sebagai kata sandi Anda. Alih-alih membuat kata sandi sendiri, Anda dapat menggunakan perintah openssl untuk menghasilkan kata sandi acak, seperti dalam contoh berikut. Dengan memasukkan keluaran dari perintah pertama ke perintah openssl kedua, seperti yang ditunjukkan di sini, hal tersebut akan menghapus jeda baris apa pun yang dihasilkan oleh perintah pertama:

      • openssl rand 60 | openssl base64 -A

      Keluaran Anda akan terlihat seperti:

      Output

      RBOJ9cCNoGCKhlEBwQLHri1g+atWgn4Xn4HwNUbtzoVxAYxkiYBi7aufl4MILv1nxBqR4L6NNzI0X6cE

      Setelah menyalin dan menempel keluaran dari perintah itu sebagai nilai baru untuk requirepass, maka keluarannya akan berbunyi:

      /etc/redis/redis.conf

      requirepass RBOJ9cCNoGCKhlEBwQLHri1g+atWgn4Xn4HwNUbtzoVxAYxkiYBi7aufl4MILv1nxBqR4L6NNzI0X6cE

      Setelah menetapkan kata sandi, simpan dan tutup berkas, lalu mulai ulang Redis:

      • sudo systemctl restart redis.service

      Untuk menguji bahwa kata sandi itu bekerja, buka klien Redis:

      Yang berikut ini menunjukkan urutan perintah yang digunakan untuk menguji apakah kata sandi Redis berfungsi. Perintah pertama mencoba untuk mengatur kunci atas suatu nilai sebelum autentikasi:

      Itu tidak akan berhasil karena Anda tidak melakukan autentikasi, jadi Redis merespons dengan pesan kesalahan:

      Output

      (error) NOAUTH Authentication required.

      Perintah selanjutnya mengautentikasi dengan kata sandi yang ditentukan di dalam berkas konfigurasi Redis:

      Redis mengakui:

      Output

      OK

      Setelah itu, menjalankan perintah sebelumnya lagi akan menjadi berhasil:

      Output

      OK

      get key1 melakukan kueri terhadap Redis untuk nilai dari kunci yang baru.

      Output

      "10"

      Setelah mengonfirmasi bahwa Anda dapat menjalankan perintah di dalam klien Redis setelah melakukan autentikasi, Anda dapat keluar dari redis-cli:

      Selanjutnya, kita akan membahas tentang mengganti nama perintah Redis yang, jika dimasukkan secara tidak sengaja atau oleh aktor jahat, dapat menyebabkan kerusakan serius pada mesin Anda.

      Langkah 5 — Mengganti Nama Perintah Berbahaya

      Fitur keamanan lain yang ditanam di dalam Redis melibatkan penggantian nama atau menonaktifkan secara penuh perintah-perintah tertentu yang dianggap berbahaya.

      Ketika dijalankan oleh pengguna yang tidak sah, perintah seperti itu dapat digunakan untuk mengonfigurasi ulang, menghancurkan, atau menghapus data Anda. Seperti kata sandi autentikasi, mengganti nama atau menonaktifkan perintah dikonfigurasi pada bagian SECURITY yang sama dari berkas /etc/redis/redis.conf.

      Beberapa perintah yang dianggap berbahaya termasuk: FLUSHDB, FLUSHALL, KEYS, PEXPIRE, DEL, CONFIG, SHUTDOWN, BGREWRITEAOF, BGSAVE, SAVE, SPOP, SREM, RENAME, dan DEBUG. Ini bukanlah daftar yang lengkap, tetap mengganti nama atau menonaktifkan semua perintah di dalam daftar itu adalah titik awal yang baik untuk menambah keamanan server Redis Anda.

      Apakah Anda harus menonaktifkan atau mengganti nama perintah bergantung pada kebutuhan spesifik Anda atau situs Anda. Jika Anda tahu bahwa Anda tidak akan pernah menggunakan perintah yang dapat disalahgunakan, maka Anda dapat menonaktifkan perintah itu. Jika tidak, mungkin akan lebih baik untuk mengganti nama.

      Untuk mengganti nama atau menonaktifkan perintah Redis, buka berkas konfigurasi sekali lagi:

      • sudo nano /etc/redis/redis.conf

      Peringatan: Langkah berikut yang menunjukkan cara menonaktifkan dan mengganti nama perintah adalah contoh. Anda harus hanya memilih untuk menonaktifkan atau mengganti nama perintah yang masuk akal bagi Anda. Anda dapat meninjau daftar lengkap perintah untuk Anda dan menentukan bagaimana perintah itu mungkin dapat disalahgunakan di redis.io/commands.

      Untuk menonaktifkan perintah, cukup ganti namanya menjadi string kosong (yang ditandai oleh sepasang tanda kutip tanpa karakter di dalamnya), seperti yang ditunjukkan di bawah ini:

      /etc/redis/redis.conf

      . . .
      # It is also possible to completely kill a command by renaming it into
      # an empty string:
      #
      rename-command FLUSHDB ""
      rename-command FLUSHALL ""
      rename-command DEBUG ""
      . . .
      

      Untuk mengganti nama perintah, beri nama lain seperti yang ditunjukkan dalam contoh di bawah ini. Perintah yang diganti namanya harus sulit ditebak oleh orang lain, tetapi mudah untuk Anda ingat:

      /etc/redis/redis.conf

      . . .
      # rename-command CONFIG ""
      rename-command SHUTDOWN SHUTDOWN_MENOT
      rename-command CONFIG ASC12_CONFIG
      . . .
      

      Simpan perubahan Anda dan tutup berkas.

      Setelah mengganti nama perintah, terapkan perubahan dengan memulai ulang Redis:

      • sudo systemctl restart redis.service

      Untuk menguji perintah baru, masuk ke baris perintah Redis:

      Lalu, lakukan autentikasi:

      Output

      OK

      Mari kita berasumsi bahwa Anda telah mengganti nama perintah CONFIG menjadi ASC12_CONFIG, seperti dalam contoh sebelumnya. Pertama-tama, coba gunakan perintah CONFIG yang asli. Ini akan gagal, karena Anda telah mengubah namanya:

      Output

      (error) ERR unknown command `config`, with args beginning with:

      Namun, menggunakan perintah yang telah diubah namanya akan berhasil. Ini tidak peka huruf kapital:

      • asc12_config get requirepass

      Output

      1) "requirepass" 2) "your_redis_password"

      Terakhir, Anda dapat keluar dari redis-cli:

      Perhatikan bahwa jika Anda sudah menggunakan baris perintah Redis lalu memulai ulang Redis, Anda akan perlu melakukan autentikasi ulang. Jika tidak, Anda akan mendapat pesan kesalahan ini jika Anda mengetik perintah:

      Output

      NOAUTH Authentication required.

      Mengenai praktik mengganti nama perintah, ada pernyataan peringatan di bagian akhir dari SECURITY di dalam /etc/redis/redis.conf yang berbunyi:

      /etc/redis/redis.conf

      . . .
      # Please note that changing the name of commands that are logged into the
      # AOF file or transmitted to replicas may cause problems.
      . . .
      

      Catatan: Proyek Redis memilih untuk menggunakan istilah “master” dan “slave”, sedangkan DigitalOcean secara umum lebih menyukai istilah alternatif “primary” dan “secondary”. Untuk menghindari kebingungan, kami memilih untuk menggunakan istilah yang digunakan dalam dokumentasi Redis di sini.

      Artinya, jika penggantian nama perintah tidak ada dalam berkas AOF, atau jika itu ada tetapi berkas AOF belum dikirim ke slave, maka seharusnya tidak ada masalah.

      Maka, ingatlah hal itu ketika Anda mencoba mengganti nama perintah. Waktu terbaik untuk mengganti nama perintah adalah saat Anda tidak menggunakan persistensi AOF, atau segera setelah instalasi, yang artinya, sebelum aplikasi yang menggunakan Redis disebarkan.

      Ketika Anda menggunakan AOF dan menangani instalasi master-slave, pertimbangkan jawaban dari laman masalah proyek Github ini. Berikut ini adalah jawaban dari pertanyaan penulis:

      Perintah-perintah dicatat ke AOF dan direplikasi ke slave dengan cara pengiriman yang sama, maka jika Anda mencoba untuk memainkan AOF kembali pada suatu instans yang tidak memiliki penggantian nama yang sama, Anda mungkin akan menghadapi inkonsistensi karena perintah tidak dapat dieksekusi (sama untuk slave).

      Dengan demikian, cara terbaik untuk menangani penggantian nama dalam kasus seperti itu adalah dengan memastikan bahwa mengganti nama perintah diterapkan pada semua instans dalam instalasi master-slave.

      Kesimpulan

      Dalam tutorial ini, Anda telah menginstal dan mengonfigurasi Redis, memvalidasi bahwa instalasi Redis Anda berfungsi dengan benar, dan menggunakan fitur keamanan bawaannya untuk membuatnya lebih tidak rentan terhadap serangan dari aktor-aktor jahat.

      Harap diingat bahwa setelah seseorang log masuk ke server Anda, maka sangat mudah untuk mengakali fitur keamanan spesifik Redis yang kita sudah atur. Oleh karena itu, fitur keamanan yang paling penting pada server Redis adalah firewall (yang Anda konfigurasikan jika Anda mengikuti tutorial prasyarat Penyiapan Server Awal ini, karena ini membuat aktor jahat sangat kesulitan untuk melompati pagar keamanan.



      Source link