Aprende a crear una instancia de cliente almacenada en caché de Guzzle utilizando el modelo de caché del sistema de archivos en tu proyecto Laravel.

Un componente de caché siempre es útil tanto en el servidor como en el lado del cliente. A veces, cuando trabaja en el lado del servidor con PHP y utiliza Laravel Framework, deberá solicitar información de otro servidor en su propio servidor. Guzzle, el cliente HTTP extensible de PHP es una de las bibliotecas más utilizadas para solicitar información de las API web utilizando PHP, ya que facilita el envío de solicitudes HTTP y simplifica la integración con los servicios web.

Si el servicio web al que está intentando acceder requiere que implemente un caché, debido a la limitación de solicitudes, siempre puede implementar un caché para el Cliente Guzzle, por lo que nunca obtendrá la   excepción 429 Demasiadas solicitudes. en su código. Esto se puede hacer, como se mencionó, porque la API que está utilizando lo requiere o simplemente porque desea acelerar las solicitudes en su servidor (como generalmente un servicio ya debería implementar un caché). En este artículo, aprenderá cómo implementar un caché basado en el sistema de archivos para Guzzle siguiendo la interfaz PSR-6. El objetivo de este PSR es permitir a los desarrolladores crear bibliotecas con memoria caché que puedan integrarse en marcos y sistemas existentes sin la necesidad de un desarrollo personalizado.

¿Cómo funciona la caché del sistema de archivos?

Al usar el Cliente en caché de Guzzle que vamos a implementar usando el sistema de archivos en lugar de un cliente simple, se creará una nueva carpeta en el directorio de caché de tu proyecto Symfony (en este caso, el nombre de nuestra nueva carpeta será GuzzleFileCache, entonces la carpeta se ubicará en  yourlaravelproject/bootstrap/GuzzleFileCache). El cliente se puede utilizar como cualquier cliente Http de Guzzle normal.

Importante

No olvide otorgar los permisos adecuados para escribir en la carpeta (al menos en el entorno de producción en caso de que esté implementando en su servidor).

Implementación

Para implementar un cliente de caché basado en archivos, puede seguir los 2 sencillos pasos:

1. Instalar librerias de caché

Además de Guzzle (obviamente), necesitará instalar el Componente Symfony Cache y las bibliotecas Guzzle Cache Middleware . El componente de caché de Symfony proporciona una implementación de PSR-6 extendida, así como una implementación de "caché simple" de PSR-16 para agregar caché a sus aplicaciones. Está diseñado para tener una sobrecarga baja y se envía con adaptadores listos para usar para los backends de almacenamiento en caché más comunes. El middleware de caché de Guzzle aumenta la funcionalidad de los controladores invocándolos en el proceso de generación de respuestas.

Para instalar las bibliotecas necesarias, ejecute los siguientes comandos del compositor en el directorio de su proyecto con su terminal:

REM Instale el componente de caché de Symfony:
composer require symfony/cache

REM E instale Cache Middleware para Guzzle:
composer require kevinrob/guzzle-cache-middleware

Después de la instalación de las 2 bibliotecas, podrá usar sus clases en su propio controlador (o servicios).

2. Crear una instancia de cliente en caché

El uso del cliente debe ser el mismo de siempre, lo que cambia es el proceso para crear e instanciar el cliente. Vamos a simplificar la lógica envolviendo todo en una sola función, es decir, getGuzzleFileCachedClientque devuelve una instancia de un cliente HTTP que implementa un caché basado en archivos.

Para comenzar, debe saber qué clases de bibliotecas se utilizarán:

use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use Kevinrob\GuzzleCache\CacheMiddleware;
use Kevinrob\GuzzleCache\Storage\Psr6CacheStorage;
use Symfony\Component\Cache\Adapter\FilesystemAdapter;
use Kevinrob\GuzzleCache\Strategy\PrivateCacheStrategy;
use Kevinrob\GuzzleCache\Strategy\GreedyCacheStrategy;

El almacenamiento en caché que usaremos será el sistema de archivos con PSR-6, por lo que debe crear una instancia del mismo como el primero que reciba como primer argumento una instancia del FilesystemAdapter. Esta instancia de FilesystemAdapter especifica el TTL de la caché, su nombre de contenedor y ruta absoluta. El TTL (o tiempo de vida) es la cantidad de tiempo entre el momento en que ese artículo se almacena y se considera obsoleto. El TTL normalmente se define mediante un número entero que representa el tiempo en segundos o un DateIntervalobjeto. Este tiempo se proporciona en FilesystemAdapter y GreedyCacheStrategy.

Luego, puede agregar el Método Cache a Guzzle usando el método push de un HandlerStack vacío que recibe como primer argumento una instancia de Cache Middleware y como segundo argumento el método codicioso-caché, que a su vez recibe como primer argumento una instancia del GreedyCacheStrategy. Esta última instancia recibe como primer argumento la instancia creada del File Cache Storage y el TTL:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

// Include require classes
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use Kevinrob\GuzzleCache\CacheMiddleware;
use Kevinrob\GuzzleCache\Storage\Psr6CacheStorage;
use Symfony\Component\Cache\Adapter\FilesystemAdapter;
use Kevinrob\GuzzleCache\Strategy\PrivateCacheStrategy;
use Kevinrob\GuzzleCache\Strategy\GreedyCacheStrategy;

class DefaultController extends Controller
{
    /**
    * Index route
    *
    * @return Response
    */
    public function index()
    {
        // Create a Custom Cached Guzzle Client
        $client = $this->getGuzzleFileCachedClient();
        
        // Use the client as you want and need, for example:
        $res = $client->request('GET', 'https://api.github.com/repos/guzzle/guzzle');
        
        // Dump for example the status on the view
        dump($res->getStatusCode());
        
        // Do what you need to do with the data of the request
        return view('default', array(

        ));
    }

    /**
    * Returns a GuzzleClient that uses a file based cache manager
    *
    * @return Guzzle Http Client
    */
    private function getGuzzleFileCachedClient(){
        // Crear un HandlerStack
        $stack = HandlerStack::create();

        // 10 minutos para mantener el caché
        // Este valor obviamente cambiará según lo necesite
        $TTL = 600;

        // Crear carpeta de caché de archivos Guzzle dentro de la ruta de la carpeta de caché proporcionada
        $requestCacheFolderName = 'GuzzleFileCache';

        // Recupere la ruta de la carpeta bootstrap de su proyecto Laravel
        $cacheFolderPath = base_path() . "/bootstrap";
        
        // Cree una instancia del almacenamiento en caché: un caché del sistema de archivos PSR-6 con
        // una vida útil predeterminada de 10 minutos (60 segundos).
        $cache_storage = new Psr6CacheStorage(
            new FilesystemAdapter(
                $requestCacheFolderName,
                $TTL, 
                $cacheFolderPath
            )
        );
        
        // Agregar método de caché
        $stack->push(
            new CacheMiddleware(
                new GreedyCacheStrategy(
                    $cache_storage,
                    $TTL // el TTL en segundos
                )
            ), 
            'greedy-cache'
        );
        
        // Inicialice el cliente con la opción de controlador y devuélvalo
        return new Client(['handler' => $stack]);
    }
}

Obviamente, para mantener sus controladores lo más delgados posible, puede crear un nuevo servicio laravel para inyectar el cliente en caché también. El uso del cliente, creará una carpeta en la /bootstrap carpeta de su proyecto con el nombre de pila:

Cache Guzzle File Based

Contendrá (una vez que ejecute algunas solicitudes) sus solicitudes en caché en PSR-6. Como todo caché, eliminar el contenido de la carpeta (o la carpeta en sí) limpiará el caché o se limpiará solo cuando expire el TTL.

Que te diviertas ❤️!


Interesado en la programación desde los 14 años, Carlos es un programador autodidacta, fundador y autor de la mayoría de los artículos de Our Code World.

Conviertete en un programador más sociable

Patrocinadores