Como criar serviços assíncronos no Symfony: processamento de tarefas em segundo plano

Introdução

O Symfony é um dos mais populares frameworks de desenvolvimento web em PHP. Ele oferece uma variedade de ferramentas, incluindo a capacidade de criar serviços assíncronos para processar tarefas em segundo plano. Neste artigo, vamos explorar como criar serviços assíncronos no Symfony para lidar com tarefas de processamento longas e de alto desempenho.

O que são serviços assíncronos no Symfony?

Serviços assíncronos são processos que são executados em segundo plano, sem bloquear o processo principal da aplicação. A ideia é que sua aplicação possa continuar a funcionar normalmente, enquanto determinadas tarefas são executadas em segundo plano, melhorando a escalabilidade e o desempenho do seu aplicativo.

Como criar serviços assíncronos no Symfony?

Para criar um serviço assíncrono no Symfony, você precisa seguir estas etapas:

1. Instalar o componente Messenger do Symfony com o Composer.
2. Crie uma classe de comando Symfony que dispare uma mensagem para a fila de mensagens.
3. Crie um manipulador no seu serviço para lidar com a mensagem.
4. Configure seu serviço para usar o manipulador.
5. Rode o consumidor de fila no seu ambiente de produção.

Exemplo completo de criação de serviço assíncrono com Symfony

A primeira etapa é instalar o componente Messenger do Symfony. Para isso, execute o seguinte comando no terminal:

composer require symfony/messenger

Em seguida, crie a classe do comando. O comando descreve a mensagem que será enviada para a fila de mensagens. Vamos criar um comando “LongTaskCommand” que recebe um ID de usuário e executa uma tarefa longa. O comando será definido no arquivo AppCommandLongTaskCommand.php:

    namespace AppCommand;

    use SymfonyComponentConsoleCommandCommand;

    use SymfonyComponentConsoleInputInputArgument;

    use SymfonyComponentConsoleInputInputInterface;

    use SymfonyComponentConsoleOutputOutputInterface;
    class LongTaskCommand extends Command

    {

        private $messageBus;
        public function __construct(MessageBusInterface $messageBus)

        {

            $this->messageBus = $messageBus;
            parent::__construct();

        }
        protected function configure()

        {

            $this

                ->setName('app:long-task')

                ->setDescription('Executes a long running task for a given user')

                ->addArgument('user_id', InputArgument::REQUIRED, 'The user ID')

            ;

        }
        protected function execute(InputInterface $input, OutputInterface $output)

        {

            $userId = $input->getArgument('user_id');
            $output->writeln(sprintf('Starting long task for user %s', $userId));
            $this->messageBus->dispatch(new LongTaskMessage($userId));

        }

    }

Agora, crie um manipulador para lidar com a mensagem. O manipulador será responsável por executar a tarefa longa. Vamos definir o manipulador no arquivo AppMessageHandlerLongTaskHandler.php:

    namespace AppMessageHandler;

    use AppMessageLongTaskMessage;

    use SymfonyComponentMessengerHandlerMessageHandlerInterface;
    class LongTaskHandler implements MessageHandlerInterface

    {

        public function __invoke(LongTaskMessage $message)

        {

            sleep(30);
            echo sprintf('Long task complete for user %s', $message->getUserId());

        }

    }

Agora, configure o serviço em services.yaml, dizendo ao Symfony para usar o manipulador para lidar com a mensagem. O arquivo de configuração está localizado em configservices.yaml:

    AppMessageHandlerLongTaskHandler:

        tags:

            - { name: messenger.message_handler, bus: messenger.bus.async }

Finalmente, execute o consumidor de fila no seu ambiente de produção com o seguinte comando:

bin/console messenger:consume async

Agora estamos prontos para executar a tarefa longa. Para fazer isso, execute o comando “app:long-task” com o ID de usuário como argumento:

bin/console app:long-task 123

A mensagem será enviada para a fila e o manipulador será invocado. Ele espera 30 segundos antes de imprimir “Long task complete for user 123”. A melhor parte é que a aplicação está completamente desacoplada da execução do manipulador. Isso significa que se a execução demorar mais, a aplicação continuará funcionando normalmente, sem bloqueios.

Conclusão

Criar serviços assíncronos pode melhorar significativamente a escalabilidade e o desempenho da sua aplicação PHP. O Symfony torna isso fácil com o componente Messenger. Isso pode ser usado para processar tarefas longas, como gerar relatórios ou enviar e-mails em segundo plano. Implementando serviços assíncronos, você pode criar uma aplicação altamente responsiva enquanto mantém a experiência do usuário estável e confiável.