En el ecosistema moderno, · Se trata de , de y Como desarrollador Senior Symfony, usted sabe que las consultas LIKE %...% son una trampa de deuda técnica. “search” is not just about finding text performance relevance user experience Este artículo detalla cómo implementar una Integración de Elasticsearch en Symfony 7.4.No estamos simplemente “instalando un paquete”; estamos construyendo una arquitectura de búsqueda resiliente y con tiempo de inactividad cero utilizando , de y por . production-grade PHP 8.4 features Attributes Symfony Messenger asynchronous indexing La arquitectura: rendimiento y resiliencia En una implementación junior, una actualización de entidad desencadena una llamada HTTP sincronizada a Elasticsearch. Si Elastic está abajo, su usuario no puede guardar sus datos. Nuestra estrategia de producción: 
 
 
 
 Zero-Downtime Indexing: Nunca escribimos directamente al índice en vivo. Nosotros escribimos a un índice marcado con el tiempo y usamos un alias para apuntar la aplicación a la versión en vivo actual. Índice Async: los escritos de base de datos se desconectan de los escritos de búsqueda usando Symfony Messenger. Tipo estricto: Utilizamos DTOs y servicios fuertemente tipados, evitando "arreglos mágicos" donde sea posible. Requisitos y instalación Se utilizará f (v7.0+). proporciona la mejor abstracción sobre el crudo cliente mientras se adhiere a los estándares de configuración de Symfony. riendsofsymfony/elastica-bundle elasticsearch-php Requisitos ambientales: 
 
 
 
 PHP 8.2 y más (rec. Sinfonía 7.4 Elasticsearch 8.x Instalación de dependencias Haz lo siguiente en tu terminal: composer require friendsofsymfony/elastica-bundle "^7.0"
composer require symfony/messenger
composer require symfony/serializer
 Configuración Ambiental Añade tu En tu En la producción, asegúrese de que esto se almacene en un administrador secreto (como o ) de Elasticsearch DSN .env Symfony Secrets HashiCorp Vault # .env
ELASTICSEARCH_URL=http://localhost:9200/
 La configuración “Zero-Downtime” Aquí es donde la mayoría de los tutoriales fallan. Configuran un nombre de índice estático. Configuraremos una estrategia aliada para permitir el reindexado de fondo sin bajar el sitio. Crear o actualizar : config/packages/fos_elastica.yaml # config/packages/fos_elastica.yaml
fos_elastica:
    clients:
        default:
            url: '%env(ELASTICSEARCH_URL)%'
            # Production Tip: Increase timeout for bulk operations
            config:
                connect_timeout: 5
                timeout: 10

    indexes:
        app_products:
            # "use_alias: true" is critical for zero-downtime reindexing
            use_alias: true 
            
            # Define your distinct settings (analyzers, filters)
            settings:
                index:
                    analysis:
                        analyzer:
                            app_analyzer:
                                type: custom
                                tokenizer: standard
                                filter: [lowercase, asciifolding]

            # Your Persistence strategy (Doctrine integration)
            persistence:
                driver: orm
                model: App\Entity\Product
                provider: ~
                # CRITICAL: We disable the default listener to use Messenger instead
                listener: 
                    insert: false
                    update: false
                    delete: false
                finder: ~

            # Explicit Mapping (Always prefer explicit over dynamic for production)
            properties:
                id: { type: integer }
                name: 
                    type: text 
                    analyzer: app_analyzer
                    fields:
                        keyword: { type: keyword, ignore_above: 256 }
                description: { type: text, analyzer: app_analyzer }
                price: { type: float }
                stock: { type: integer }
                created_at: { type: date }
 El nivel de dominio Supongamos una entidad de producto estándar. Utilizamos los atributos estándar de PHP 8. namespace App\Entity;

use App\Repository\ProductRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: ProductRepository::class)]
#[ORM\Table(name: 'products')]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $name = null;

    #[ORM\Column(type: Types::TEXT)]
    private ?string $description = null;

    #[ORM\Column]
    private ?float $price = null;

    #[ORM\Column]
    private ?int $stock = 0;

    #[ORM\Column]
    private ?\DateTimeImmutable $createdAt = null;

    public function __construct()
    {
        $this->createdAt = new \DateTimeImmutable();
    }

    // ... Getters and Setters
    
    public function getId(): ?int
    {
        return $this->id;
    }
    
    // ...
}
 Indexación Async con Messenger (el patrón senior) En lugar de dejar ralentizar nuestras solicitudes de usuarios indexando de inmediato, enviaremos un mensaje a una cola. fos_elastica El mensaje Una sencilla Identificación de la entidad que ha cambiado. DTO (Data Transfer Object) namespace App\Message;

final readonly class IndexProductMessage
{
    public function __construct(
        public int $productId,
        // 'index' or 'delete'
        public string $action = 'index'
    ) {}
}
 Suscriptor de Event Lifecycle Escuchamos los eventos de la Doctrina para enviar automáticamente nuestro mensaje. namespace App\EventListener;

use App\Entity\Product;
use App\Message\IndexProductMessage;
use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
use Doctrine\ORM\Event\PostPersistEventArgs;
use Doctrine\ORM\Event\PostRemoveEventArgs;
use Doctrine\ORM\Event\PostUpdateEventArgs;
use Doctrine\ORM\Events;
use Symfony\Component\Messenger\MessageBusInterface;

#[AsDoctrineListener(event: Events::postPersist, priority: 500, connection: 'default')]
#[AsDoctrineListener(event: Events::postUpdate, priority: 500, connection: 'default')]
#[AsDoctrineListener(event: Events::postRemove, priority: 500, connection: 'default')]
class ProductIndexerSubscriber
{
    public function __construct(
        private MessageBusInterface $bus
    ) {}

    public function postPersist(PostPersistEventArgs $args): void
    {
        $this->dispatch($args->getObject(), 'index');
    }

    public function postUpdate(PostUpdateEventArgs $args): void
    {
        $this->dispatch($args->getObject(), 'index');
    }

    public function postRemove(PostRemoveEventArgs $args): void
    {
        // When removing, we still need the ID, but the object is technically gone from DB.
        // Ensure you capture the ID before it's fully detached if needed, 
        // but postRemove usually still has access to the object instance.
        $this->dispatch($args->getObject(), 'delete');
    }

    private function dispatch(object $entity, string $action): void
    {
        if (!$entity instanceof Product) {
            return;
        }

        $this->bus->dispatch(new IndexProductMessage($entity->getId(), $action));
    }
}
 El comerciante Aquí es donde el trabajo real ocurre en el trabajador de fondo. namespace App\MessageHandler;

use App\Entity\Product;
use App\Message\IndexProductMessage;
use App\Repository\ProductRepository;
use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
final class IndexProductHandler
{
    public function __construct(
        // Inject the specific persister for 'app_products' index
        // The service ID usually follows the pattern fos_elastica.object_persister.<index_name>.<type_name>
        // Or you can bind it via services.yaml if autowiring fails
        private ObjectPersisterInterface $productPersister,
        private ProductRepository $productRepository
    ) {}

    public function __invoke(IndexProductMessage $message): void
    {
        if ($message->action === 'delete') {
             // For deletion, we can't fetch the entity as it's gone. 
             // We pass the ID directly to the persister.
             // Note: In some setups, you might need a stub object or just the ID.
             // The ObjectPersisterInterface typically expects an object, 
             // but strictly speaking, Elastica needs an ID. 
             // A cleaner way for delete is often using the Elastica Client directly 
             // if the Persister insists on an Entity object.
             // For simplicity here, we assume the persister handles ID lookups or we use a custom service.
             
             // Production-grade approach: Use the Raw Index Service for deletes to avoid hydration issues
             // But for this example, let's focus on Indexing.
             return; 
        }

        $product = $this->productRepository->find($message->productId);

        if (!$product) {
            // Product might have been deleted before this worker ran
            return;
        }

        // This pushes the single object to Elasticsearch
        $this->productPersister->replaceOne($product);
    }
}
 Usted debe registrar el persistir explícitamente en 2 Autovía correcta, o bien utilizar Atribución si tiene múltiples índices. services.yaml ObjectPersisterInterface #[Target] # config/services.yaml
services:
    _defaults:
        bind:
            # Bind the specific persister to the argument name or type
            $productPersister: '@fos_elastica.object_persister.app_products'
 Título: El patrón de repositorio No pongas la lógica de Elastica en tus controladores. namespace App\Service\Search;

use FOS\ElasticaBundle\Finder\TransformedFinder;

class ProductSearchService
{
    public function __construct(
        // The TransformedFinder returns Doctrine Entities. 
        // If you want raw speed and arrays, use the 'index' service directly.
        private TransformedFinder $productFinder
    ) {}

    /**
     * @return array<int, \App\Entity\Product>
     */
    public function search(string $query, int $limit = 20): array
    {
        // Elastica Query Builder
        $boolQuery = new \Elastica\Query\BoolQuery();
        
        // Match name or description
        $matchQuery = new \Elastica\Query\MultiMatch();
        $matchQuery->setQuery($query);
        $matchQuery->setFields(['name^3', 'description']); // Boost name by 3x
        $matchQuery->setFuzziness('AUTO'); // Handle typos
        
        $boolQuery->addMust($matchQuery);
        
        // Filter by stock (only in stock items)
        $stockFilter = new \Elastica\Query\Range('stock', ['gt' => 0]);
        $boolQuery->addFilter($stockFilter);

        $elasticaQuery = new \Elastica\Query($boolQuery);
        $elasticaQuery->setSize($limit);

        // Returns Hydrated Doctrine Objects
        return $this->productFinder->find($elasticaQuery);
    }
}
 Verificación y despliegue Crea el índice Antes de que su aplicación pueda funcionar, debe inicializar el índice. php bin/console fos:elastica:create
 Datos de población (carga inicial) Si tiene datos existentes en MySQL, presione a Elastic. php bin/console fos:elastica:populate
 Este comando utiliza la lógica Zero-Downtime: crea un nuevo índice, lo llena y luego cambia atómicamente el alias. Comprobar a través de cURL Compruebe si su mapeo es correcto directamente en Elastic. curl -X GET "http://localhost:9200/app_products/_mapping?pretty"
 Conclusiones Ahora tienes una arquitectura de búsqueda que: 
 
 
 
 Sobrevive a la carga de DB: La búsqueda llega a Elastic, no a MySQL. Sobrevive el tiempo de inactividad elástica: los mensajes siguen en cola en Messenger (RabbitMQ/Redis) y se retiran más tarde. Survives Reindexing: puede cambiar sus analizadores y mapeos, ejecutar fos:elastica:populate y los usuarios no notarán una cosa. Este es el estándar para aplicaciones de alto rendimiento de Symfony. ¡Contacta conmigo en Linkedin! ] para más ideas sobre la arquitectura de PHP y Symfony. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

Read My Stories

Este audio es producido en el idioma original de la historia!

La búsqueda sinfónica que no desciende: Elasticsearch Zero-Downtime + Índice Async

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

Las capas invisibles: por qué las entrevistas con los usuarios son un activo irremplazable

Telegram: el puente de Crypto Island hacia el continente

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

Las capas invisibles: por qué las entrevistas con los usuarios son un activo irremplazable

Telegram: el puente de Crypto Island hacia el continente

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps