Todo lo que necesita saber sobre el almacenamiento en caché de Laravel

El almacenamiento en caché es esencial para lograr un alto rendimiento y escalabilidad. Implementar la estrategia de almacenamiento en caché adecuada desde la fase de desarrollo es fundamental para evitar API retrasadas y tiempos de carga de página lentos. Laravel es uno de los frameworks PHP más populares, por lo que implementar la estrategia óptima de almacenamiento en caché de Laravel es indispensable para una mejor experiencia de usuario y un mayor impacto comercial.

En este artículo, exploraremos estrategias para implementar y manipular el almacenamiento en caché en Laravel. Aprenderá cómo funciona el almacenamiento en caché de Laravel, varias consultas de almacenamiento en caché de Laravel y cómo puede manejar el almacenamiento en caché en las aplicaciones de Laravel.

Obtendrá más de este artículo si ya tiene un conocimiento básico de lo siguiente en su haber:

¡Vamos a sumergirnos!

¿Por qué es importante el almacenamiento en caché?

Con el reciente auge de los negocios de Internet, diferentes empresas tienen estadísticas que muestran cómo el tiempo de carga del sitio web y el bajo rendimiento pueden afectar en gran medida al SEO, la participación del usuario y las tasas de conversación sin almacenamiento en caché. Y eso comienza con una excelente estrategia de almacenamiento en caché.

Un estudio en línea encontró que «1 segundo de tiempo de demora de carga le costaría a Amazon $ 1.6 mil millones en ventas por año».

Otro estudio de Google informó: «Nuestra investigación muestra que si los resultados de búsqueda se ralentizan incluso una fracción de segundo, la gente busca menos (en serio: A Retardo de 400ms conduce a un 0,44 por ciento de caída en volumen de búsqueda, ventiladores de datos). Y esta impaciencia no se limita solo a la búsqueda: cuatro de cada cinco usuarios de Internet harán clic si un video se detiene mientras se carga «.

Una leve lentitud en el tiempo de carga de su página web puede resultar en un impacto masivo en la experiencia de sus usuarios y pérdida de fondos en general.

¿Qué es el almacenamiento en caché de Laravel?

Laravel proporciona una implementación robusta y fácil de usar de almacenamiento en caché y diferentes backends de almacenamiento en caché. Con la caché de Laravel, puede cambiar de manera eficiente y efectiva entre muchos motores de almacenamiento en caché sin escribir ningún código.

Puede encontrar la configuración de la caché de Laravel dentro del config/cache.php carpeta, aunque es probable que solo necesite la .env para cambiar entre diferentes backends de caché.

La caché de Laravel también proporciona muchos métodos prácticos que podemos utilizar para implementar diferentes estrategias de almacenamiento en caché.

El almacenamiento en caché es una parte esencial del proceso de desarrollo de software para cualquier persona que se preocupe más por el alto rendimiento y la escalabilidad. 📈 Sumérjase en todo lo que necesita saber sobre el almacenamiento en caché de Laravel aquí 🚀Haz clic para tuitear

Controladores de caché de Laravel y comparaciones

La caché de Laravel proporciona excelentes controladores y backends de almacenamiento en caché. Dependiendo de su caso de uso, puede cambiar entre ellos para mejorar el rendimiento de su aplicación y el tiempo de carga.

Dicho esto, la caché de Laravel también proporciona una forma perfecta de crear un backend personalizado y usarlo con la caché de Laravel, pero solo si la lista a continuación no se ajusta a su caso de uso.

A continuación, hablaremos de la lista de todos los backends proporcionados por la caché de Laravel.

1. Archivo

los expediente El controlador es el backend predeterminado utilizado por la caché de Laravel cuando no se especifica ningún controlador en el .env expediente.

los expediente backend está diseñado para almacenar los datos en caché en un archivo cifrado que se encuentra en storage/framework/. Laravel crea un archivo cifrado con los datos y la clave de caché cuando se almacenan en caché nuevos datos. Lo mismo ocurre cuando el usuario intenta recuperar el contenido. La caché de Laravel busca en la carpeta la clave especificada y, si la encuentra, devuelve el contenido.

Aunque el expediente El backend funciona a la perfección y ahorra tiempo instalando y configurando controladores externos; también puede ser perfecto para el desarrollo. Es más rápido que acceder directamente a los datos del servidor de la base de datos.

Usar el expediente controlador, agregue el siguiente código a su .env expediente:

CACHE_DRIVER=file

2. Matriz

los formación El controlador es un backend de almacenamiento en caché perfecto para ejecutar pruebas automatizadas y se configura fácilmente con Github Actions, Jenkins, etc.

los formación El backend almacena los datos en caché en una matriz en PHP y no requiere que instale o configure ningún controlador. Funciona perfectamente para pruebas automatizadas y es un poco más rápido que el backend de la caché de archivos.

Usar el formación controlador, agregue el siguiente código a su .env expediente:

CACHE_DRIVER=array

3. Base de datos

Al usar el base de datos controlador, los datos se almacenan en la memoria para el proceso PHP actual. Por lo tanto, debe crear una tabla de base de datos para almacenar los datos en caché. Además, el almacenamiento en caché de la base de datos mejora la escalabilidad al distribuir la carga de trabajo de consultas desde el backend a varios frontends.

Puede ejecutar este comando Artisan: php artisan cache:table – para generar automáticamente el esquema de la base de datos que necesita el controlador de la base de datos.

los base de datos El controlador se utiliza principalmente en situaciones en las que puede instalar cualquier software en su plataforma de alojamiento.

Por ejemplo, digamos que está utilizando un plan de alojamiento gratuito con opciones limitadas. Para eso, le sugerimos que se ciña a la expediente conductor porque el base de datos El controlador es, en la mayoría de los casos, el punto más débil de su aplicación, y tratar de introducir más datos en ese cuello de botella no es una buena idea.

Usar el base de datos controlador, agregue el siguiente código a su .env expediente:

CACHE_DRIVER=database

4. Redis

los redis El controlador utiliza la tecnología de almacenamiento en caché basada en memoria llamada Redis.. Aunque es rápido en comparación con los otros controladores de caché mencionados anteriormente, requiere instalar y configurar tecnología externa.

Usar el redis controlador, agregue el siguiente código a su .env expediente:

CACHE_DRIVER=redis

5. Memcached

Memcached es conocido por ser el almacén de caché basado en memoria más popular. Si no le importa un poco de mantenimiento adicional del servidor (tener que instalar y mantener servicios adicionales), los controladores de caché basados ​​en memoria Memcached son excelentes opciones.

Utilizando el memcached El controlador requiere la instalación del paquete Memcached PECL.

Usar el memcached controlador, agregue el siguiente código a su .env expediente.

CACHE_DRIVER=memcached 

El mejor controlador de caché para usar y el rendimiento del controlador de caché dependen del caso de uso de su proyecto y la cantidad de datos que se recuperarán.

Métodos y uso de la caché de Laravel

La caché de Laravel proporciona muchos métodos valiosos que se utilizan para implementar muchas estrategias de almacenamiento en caché.

A continuación, enumeraremos y explicaremos los diferentes métodos (categorizados según su caso de uso):

1. put()
2. get()
3. many()
4. putMany()
5. increment()
6. decrement()
7. forever()
8. forget()
9. flush()
10. remember()
11. rememberForever()

Almacenamiento de caché

Almacenar nuevos datos en la caché es muy simple usando los diferentes métodos, cada uno con varios casos de uso.

1. Caché :: put ()

Este método acepta tres parámetros clave, duración, y el datos para ser almacenado en caché.

Echemos un vistazo a cómo usar Cache::put():

Cache::put(key, data, duration)

$post = Post::find(1);

Cache::put('post_1', $post, 20);

El código anterior almacenará en caché la publicación con el único llave durante 20 segundos.

2. Caché :: putMany ()

Este método almacena una matriz de datos en la caché a la vez con la misma duración. Acepta dos parámetros que son datos y segundos.

Echemos un vistazo a cómo usar Cache::putMany():

Cache::putMany(data, duration) // syntax

$posts = Post::all();

Cache::putMany($posts, 20);

3. Caché :: recordar ()

Este método es otra forma excelente de implementar la estrategia de caché aparte. los Cache::remember() El método acepta tres parámetros, un llave, segundos, y cierre utilizado para recuperar datos de la base de datos si no se encuentran.

Echemos un vistazo a cómo usar Cache::remember():

Cache::remember(key, duration, closure) // syntax

Cache::remember('posts', 20, function(){
  return Post::all();
});

La caché de Laravel también tiene la Cache::rememberForever() método, que no acepta el segundos parámetro y almacena el datos para siempre.

4. Caché :: para siempre ()

Este método almacena datos en el servidor de caché para siempre sin especificar ninguna duración. Puedes implementarlo con el siguiente código:

Cache::forever(key, data)

$post = Post::find(1);

Cache::forever('post_1', $post);

Recuperar datos de la caché

Los métodos de esta categoría recuperan datos de la caché. Algunos de estos métodos pueden comportarse de manera diferente dependiendo de si los datos se encuentran o no.

1. Caché :: get ()

Este método recupera datos del servidor de caché con una clave específica. Puede recuperar un artículo utilizando el siguiente código:

Cache::get(key) // syntax

$posts = Cache::get('posts');

2. Caché :: muchos ()

Este método es similar a Cache::putMany(). Se utiliza para recuperar una matriz de datos almacenados en caché a la vez utilizando una matriz de claves almacenadas en caché. Puede recuperar una matriz de caché usando lo siguiente código:

Cache::many(keys) // syntax

const $keys = [
  'posts',
  'post_1',
  'post_2'
];

$posts = Cache::many($keys);

3. Caché :: recordar ()

También puede utilizar este método para recuperar datos almacenados en caché comprobando el servidor de caché con la clave proporcionada. Si los datos se almacenan en la caché, los recuperará. De lo contrario, recuperará los datos del servidor de base de datos y los almacenará en caché. Este método es el mismo que el Cache::rememberForever() método con solo un extra segundos parámetro en el Cache::remember() método.

Eliminar elementos de la caché

Los métodos de esta categoría se utilizan para eliminar elementos de la caché, agrupados por funcionalidad.

1. Caché :: olvidar ()

Este método elimina un solo elemento de la caché con un parámetro clave específico:

Cache::forget('key');

2. Caché :: flush ()

Este método borra todos los motores de caché. Elimina todos los elementos almacenados en cualquier lugar de la caché:

Cache::flush();

Incrementar o disminuir los valores de la caché

Puede ajustar los valores de un valor entero almacenado en su caché usando los métodos de incremento y decremento, respectivamente:

Cache::increment('key');

Cache::increment('key', $amount);

Cache::decrement('key');

Cache::decrement('key', $amount);

La caché de Laravel tiene muchos métodos excelentes que no hemos discutido anteriormente, pero los métodos anteriores son populares. Puede obtener una descripción general de todos los métodos en la documentación oficial de la caché de Laravel.

Explicación de los comandos de caché

Laravel proporciona comandos para que trabajar con la caché de Laravel sea fácil y rápido. A continuación se muestra la lista de todos los comandos y sus funcionalidades.

Borrar caché de Laravel

Este comando se usa para borrar la caché de Laravel incluso antes de que expire usando la terminal / consola. Por ejemplo, puede ejecutar el siguiente comando:

php artisan cache:clear

Borrar ruta-caché

Este comando se usa para borrar el caché de ruta de su aplicación Laravel. Por ejemplo, ejecute el siguiente comando para borrar la memoria caché de su ruta:

php artisan config:cache

Borrar archivos de vista compilados

Este comando se usa para borrar los archivos de vista compilados de su aplicación Laravel. Puedes lograrlo con el siguiente comando:

php artisan view:clear

Tabla de base de datos

Al utilizar el controlador de la base de datos, debe crear un esquema de base de datos llamado cache para almacenar los datos de la caché. También puede usar el comando Artisan para generar una migración con el esquema adecuado:

php artisan cache:table

Estrategias de almacenamiento en caché de Laravel

Según el caso de uso de su aplicación y la estructura de datos, es probable que tenga disponibles varias estrategias de caché diferentes. Incluso puede crear una estrategia personalizada que se adapte a sus necesidades. A continuación, repasaremos la lista de estrategias populares de almacenamiento en caché que puede implementar en su proyecto Laravel.

escriba por medio de

En el escriba por medio de estrategia, el servidor de caché se encuentra entre las solicitudes y el servidor de la base de datos, haciendo que cada escribir La operación pasa por el servidor de caché antes de ir al servidor de base de datos. Por lo tanto, la escriba por medio de La estrategia de almacenamiento en caché es similar a la leer de parte a parte estrategia.

Puedes implementar esta estrategia con la caché de Laravel con el siguiente código:

public function writeThrough($key, $data, $minutes) {
    $cacheData = Cache::put($key, $data, $minutes)

    // Database Server is called from(after) the Cache Server.
    $this->storeToDB($cachedData)
    return $cacheData
}

private function storeToDB($data){
    Database::create($data)
    return true
}

writeBack (writeBehind)

Esta estrategia es una forma más avanzada de implementar la escriba por medio de estrategia agregando retrasos en las operaciones de escritura.

También puede llamar a esto el escribir detrás estrategia debido al retraso en el tiempo aplicado al servidor de caché antes de escribir los datos en el servidor de la base de datos.

Puedes implementar esta estrategia con la caché de Laravel con el siguiente código:

$durationToFlush = 1; // (in minute)
 $tempDataToFlush = [];

  public function writeBack($key, $data, $minutes){
    return $this->writeThrough($key, $data, $minutes);
  }

  public function writeThrough($key, $data, $minutes) {
      $cacheData = Cache::put($key, $data, $minutes);
      $this->storeForUpdates($cacheData);
      return $cacheData;
  }

// Stores new data to temp Array for updating
  private function storeForUpdates($data){
    $tempData = {};
    $tempData['duration'] = this.getMinutesInMilli();
    $tempData['data'] = data;
    array_push($tempDataToFlush, data);
  }

// Converts minutes to millisecond
private function getMinutesInMilli(){
  $currentDate = now();
  $futureDate = Carbon(Carbon::now()->timestamp + $this->durationToFlush * 60000)
  return $futureDate->timestamp
}

// Calls to update the Database Server.
public function updateDatabaseServer(){
  if($this->tempDataToFlush){
    foreach($this->tempDataToFlush as $index => $obj){
      if($obj->duration timestamp){
        if(Database::create($obj->data)){
            array_splice($this->tempDataToFlush, $index, 1);
        }
      }
    }
  }
}

los respóndeme llamadas de método al escriba por medio de método, que almacena los datos en el servidor de caché y una matriz temporal que se enviará más tarde al servidor de la base de datos utilizando el updateDatabaseServer método. Puede configurar un CronJob para actualizar el servidor de la base de datos cada cinco minutos.

writeAround

Esta estrategia permite que todos los escribir operaciones para ir directamente al servidor de la base de datos sin actualizar el servidor de caché, solo durante el leer operaciones es el servidor de caché actualizado.

Suponiendo que un usuario quiere crear una nueva Artículo, los Artículo almacena directamente en el servidor de la base de datos. Cuando el usuario quiere leer el Artículocontenido por primera vez, el Artículo se recupera del servidor de la base de datos y actualiza el servidor de caché para solicitudes posteriores.

Puedes implementar esta estrategia con la caché de Laravel con el siguiente código:

public function writeAround($data) {
    $storedData = Database::create($data);
    return $storedData;
}

public function readOperation($key, $minutes){
    $cacheData = Cache::remember($key, $minutes, function() {
      return Article::all();
    })
    return $cacheData;
}

Caché aparte (carga diferida)

La base de datos está a un lado en esta estrategia y la aplicación solicita datos del servidor de caché primero. Luego, si hay un hit (encontrado), los datos se devuelven al cliente. De lo contrario, si hay un error (no encontrado), el servidor de la base de datos solicita los datos y actualiza el servidor de caché para las solicitudes posteriores.

Puedes implementar esta estrategia con la caché de Laravel con el siguiente código:

public function lazyLoadingStrategy($key, $minutes, $callback) {
  if (Cache::has($key)) {
      $data = Cache::get($key);
      return $data;
  } else {
      // Database Server is called outside the Cache Server.
      $data = $callback();
      Cache::set($key, $data, $minutes);
      return $data;
  }
}

El código anterior muestra la implementación de la estrategia de caché de lado, que es equivalente a implementar la Caché :: recordar método.

Leer de parte a parte

Esta estrategia es directamente opuesta a la estrategia de caché a un lado. En esta estrategia, el servidor de caché se encuentra entre la solicitud del cliente y el servidor de la base de datos.

Las solicitudes van directamente al servidor de caché, y el servidor de caché es responsable de recuperar los datos del servidor de base de datos si no se encuentran en el servidor de caché.

Puedes implementar esta estrategia con la caché de Laravel con el siguiente código:

public function readThrough($key, $minutes) {
      $data = Cache::find($key, $minutes);
      return $data;
}

private function find($key, $minutes){
    if(Cache::has($key);){
      return Cache::get($key);
    }

    // Database Server is called from the Cache Server.
    $DBdata = Database::find($key);
    Cache:put($key, $DBdata, $minutes);
    return $DBdata;
}

¡Ahí tienes! Ahora hemos discutido algunas estrategias populares de almacenamiento en caché para su próxima aplicación de Laravel. Recuerde, incluso puede utilizar una estrategia de almacenamiento en caché personalizada que mejor se adapte a los requisitos de su proyecto.

Almacenamiento en caché de la parte de la interfaz de usuario de una aplicación Laravel

El almacenamiento en caché de la interfaz de usuario de nuestra aplicación Laravel es un concepto conocido como FPC de caché de página completa. El término se refiere al proceso de almacenar en caché la respuesta HTML de una aplicación.

Es excelente para aplicaciones donde los datos HTML dinámicos no cambian con frecuencia. Puede almacenar en caché la respuesta HTML para obtener una respuesta general y una representación más rápidas del HTML.

Podemos implementar FPC con la siguiente línea de código:

class ArticlesController extends Controller {
    public function index() {
        if ( Cache::has('articles_index') ) {
            return Cache::get('articles_index');
        } else {
            $news = News::all();
            $cachedData = view('articles.index')->with('articles', $news)->render();
            Cache::put('articles_index', $cachedData);                                         
            return $cachedData;           
        }  
    }
}

A primera vista, es posible que haya notado que verificamos si eso articulos_index La página ya existe en nuestro servidor de caché. Luego devolvemos la página renderizándola con Laravel’s vista() y hacer() métodos.

De lo contrario, renderizamos la página y almacenamos la salida en nuestro servidor de caché para solicitudes posteriores antes de devolver la página renderizada al navegador.

Crea una aplicación Laravel

Ahora vamos a aplicar lo que hemos aprendido hasta ahora creando un nuevo proyecto de Laravel e implementando la caché de Laravel.

Si no ha usado Laravel, puede leer qué es Laravel y echar un vistazo a nuestra lista de excelentes tutoriales de Laravel para comenzar.

Configurando Laravel

Primero, crearemos una nueva instancia de Laravel usando el siguiente comando. Puede consultar la documentación oficial para obtener más información.

Abra su consola y navegue hasta donde almacena sus proyectos PHP antes de ejecutar los siguientes comandos. Asegúrese de tener Composer instalado y configurado correctamente.

composer create-project laravel/laravel fast-blog-app

// Change directory to current Laravel installation
cd fast-blog-app

// Start Laravel development server.
php artisan serve

Configurar y sembrar la base de datos

A continuación, configuraremos nuestra base de datos, crearemos una nueva Artículo modelo y sembrar 500 puntos de datos falsos para realizar pruebas.

Abra su cliente de base de datos y cree una nueva base de datos. Haremos lo mismo con el nombre fast_blog_app_db y luego llene nuestro .env archivo con las credenciales de la base de datos:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=fast_blog_app_db
DB_USERNAME=//DB USERNAME HERE
DB_PASSWORD=//DB PASSWORD HERE

A continuación, ejecutaremos el siguiente comando para crear la migración y la Artículo modelo simultáneamente:

php artisan make:model Article -m

Abra la migración recién creada encontrada database/migrations/xxx-create-articles-xxx.php y pega el siguiente código:

<?php
use IlluminateSupportFacadesSchema;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateDatabaseMigrationsMigration;
class CreateArticlesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('articles', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description');
            $table->timestamps();
        });
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('articles');
    }
}

A continuación, ejecute el siguiente comando para crear una nueva sembradora:

php artisan make:seeder ArticleSeeder

Abra el archivo de sembradora recién creado que se encuentra en database/seeders/ArticleSeeder.php y pega el siguiente código:

<?php
namespace DatabaseSeeders;
use AppModelsArticle;
use IlluminateDatabaseSeeder;
class ArticleSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        Article::factory()->count(500)->create();
    }
}

Abre el DatabaseSeeder.php archivo en el mismo directorio y agregue el siguiente código:

<?php
namespace DatabaseSeeders;
use IlluminateDatabaseSeeder;
class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        $this->call(ArticleSeeder::class);
    }
}

A continuación, ejecute el siguiente comando para crear una nueva fábrica:

php artisan make:factory ArticleFactory

Abra el archivo de fábrica recién construido que se encuentra en database/factories/ArticleFactory.php y pega el siguiente código:

<?php
namespace DatabaseFactories;
use AppModelsArticle;
use IlluminateDatabaseEloquentFactoriesFactory;
class ArticleFactory extends Factory
{
    /**
     * The name of the factory's corresponding model.
     *
     * @var string
     */
    protected $model = Article::class;
    /**
     * Define the model's default state.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'title' => $this->faker->text(),
            'description' => $this->faker->paragraph(20)
        ];
    }
}

Ahora, ejecute el comando a continuación para migrar nuestro esquema recién creado y también sembrar nuestros datos falsos para probar:

php artisan migrate --seed

Creación del controlador de artículos

A continuación, crearemos nuestro controlador y configuraremos nuestras rutas para manejar nuestra solicitud y recuperar datos utilizando lo anterior modelo.

Ejecute el siguiente comando para crear un nuevo ArtículosControlador dentro de app/Http/Controllers carpeta:

php artisan make:controller ArticlesController --resource

Abra el archivo y agregue el siguiente código a la clase:

// Returns all 500 articles with Caching
public function index() {
  return Cache::remember('articles', 60, function () {
      return Article::all();
  });
}

// Returns all 500 without Caching 
public function allWithoutCache() {
  return Article::all();
}

Después de eso, abra el api.php archivo encontrado dentro del routes/ carpeta y pegue el siguiente código para crear un punto final al que podamos llamar para recuperar nuestros datos:

Route::get('/articles', '[email protected]');

Route::get('/articles/withoutcache', '[email protected]');

Probando el rendimiento

Por último, probaremos el rendimiento de la respuesta de nuestra aplicación con o sin la implementación de la caché de Laravel.

Esta captura de pantalla muestra el tiempo de respuesta de la API con la caché implementada:

La siguiente captura de pantalla muestra el tiempo de respuesta de la API sin la caché implementada; tenga en cuenta que el tiempo de respuesta ha aumentado en la instancia en caché en más de 5.000%:

¿Tienes un conocimiento sólido del desarrollo web y laravel, pero quieres aprender más sobre el almacenamiento en caché de laravel y cómo puedes implementarlo? ✅ Esta publicación es para ti 👇Haz clic para tuitear

Resumen

Hemos explorado varias estrategias para implementar y manipular el almacenamiento en caché de Laravel mediante la creación de un nuevo proyecto, comparando sus respuestas y comparando los resultados.

También ha aprendido a utilizar los diferentes métodos y controladores de almacenamiento en caché de Laravel. Además, implementamos diferentes estrategias de almacenamiento en caché para ayudarlo a determinar cuál podría ser la adecuada para usted.

Para obtener más Laravel, explore nuestra selección cuidadosamente seleccionada de los mejores tutoriales de Laravel. Ya sea que sea un principiante o un desarrollador avanzado de Laravel, ¡hay algo para todos allí!

Si aún tiene preguntas sobre el almacenamiento en caché de Laravel, háganoslo saber en la sección de comentarios.