DEV Community: Jonathan Gonçalves

Automatizando fluxos de trabalho com GitHub Actions

Jonathan Gonçalves — Thu, 21 Dec 2023 14:02:14 +0000

Com o GitHub Actions, podemos executar fluxos de trabalho personalizados diretamente em nosso repositório. Podemos descobrir, criar e compartilhar ações para automação eficiente, CI/CD e muito mais.

Vamos automatizar o fluxo de trabalho de um projeto já bem conhecido em nossos artigos, product-api.

jmgoncalves97 / product-api

Product API

Easily start application with docker.

docker compose up

About Laravel

Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable and creative experience to be truly fulfilling. Laravel takes the pain out of development by easing common tasks used in many web projects, such as:

Simple, fast routing engine.
Powerful dependency injection container.
Multiple back-ends for session and cache storage.
Expressive, intuitive database ORM.
Database agnostic schema migrations.
Robust background job processing.
Real-time event broadcasting.

Laravel is accessible, powerful, and provides tools required for large, robust applications.

Learning Laravel

Laravel has the most extensive and thorough documentation and video tutorial library of all modern web application frameworks, making it a breeze to get started with the framework.

You may also try the Laravel Bootcamp, where you will be guided through building a modern Laravel…

View on GitHub

Vou criar duas ações que serão executadas após pull requests. A primeira realiza testes para evitar quebras de recursos, enquanto a segunda executa lint para garantir qualidade no código.

Vamos para a tab Actions em nosso repositório.

Observe que ele me sugere alguns workflows. Vamos configurar o Laravel.

name: Laravel

on:
  push:
    branches: [ "master" ]
  pull_request:
    branches: [ "master" ]

jobs:
  laravel-tests:

    runs-on: ubuntu-latest

    steps:
    - uses: shivammathur/setup-php@15c43e89cdef867065b0213be354c2841860869e
      with:
        php-version: '8.0'
    - uses: actions/checkout@v3
    - name: Copy .env
      run: php -r "file_exists('.env') || copy('.env.example', '.env');"
    - name: Install Dependencies
      run: composer install -q --no-ansi --no-interaction --no-scripts --no-progress --prefer-dist
    - name: Generate key
      run: php artisan key:generate
    - name: Directory Permissions
      run: chmod -R 777 storage bootstrap/cache
    - name: Create Database
      run: |
        mkdir -p database
        touch database/database.sqlite
    - name: Execute tests (Unit and Feature tests) via PHPUnit
      env:
        DB_CONNECTION: sqlite
        DB_DATABASE: database/database.sqlite
      run: vendor/bin/phpunit

Vamos ajustar o fluxo de trabalho para acionar em qualquer pull request, atualizar a versão do PHP para 8.1 e remover a criação do banco de dados e variáveis de ambiente, pois nosso projeto está configurado para usar banco de dados em memória durante os testes.

name: Laravel

on:
  push:
    branches: [ "master" ]
  pull_request:

jobs:
  laravel-tests:

    runs-on: ubuntu-latest

    steps:
    - uses: shivammathur/setup-php@15c43e89cdef867065b0213be354c2841860869e
      with:
        php-version: '8.1'
    - uses: actions/checkout@v3
    - name: Copy .env
      run: php -r "file_exists('.env') || copy('.env.example', '.env');"
    - name: Install Dependencies
      run: composer install -q --no-ansi --no-interaction --no-scripts --no-progress --prefer-dist
    - name: Generate key
      run: php artisan key:generate
    - name: Directory Permissions
      run: chmod -R 777 storage bootstrap/cache
    - name: Execute tests (Unit and Feature tests) via PHPUnit
      run: vendor/bin/phpunit

Agora, criaremos nosso segundo workflow responsavel por executar lint no código. Em 'Actions', clique em 'Skip this and set up a workflow yourself'. Ao pesquisar 'lint' no marketplace, encontraremos o action que precisamos. Entretanto, o .yml sugerido está incompleto, então escreveremos o nosso.

Vamos aplicar a mesma configuração para pushes e pull requests utilizado no laravel.yml. Em seguida, modificaremos os steps para utilizar a ação aglipanci/laravel-pint-action.

name: PHP Linting
on:
  push:
    branches: ["master"]
  pull_request:
jobs:
  phplint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: "laravel-pint"
        uses: aglipanci/laravel-pint-action@2.0.0
        with:
          preset: laravel
          verboseMode: true
          testMode: true
          pintVersion: 1.8.0
          onlyDirty: true

Com os workflows criados, vamos aproveitar pra passar um lint no projeto. Em seguida, faremos um pull request e aguardaremos os workflows executarem. Se tudo estiver correto, poderemos seguir com o merge do pull request.

Agora faremos o pull request de uma branch que possui um teste que falhará e chave aberta na mesma linha que o nome da classe.

<?php

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;

class FalseAssertTest extends TestCase {
    /**
     * A basic unit test example.
     */
    public function test_example(): void
    {
        $this->assertTrue(false);
    }
}

A implementação de fluxos de trabalho eficientes, agiliza a validação de código, aumenta a confiança nas alterações e aprimora o processo de CI/CD, promovendo um desenvolvimento ágil e de alta qualidade.

Testando filas em projetos Laravel

Jonathan Gonçalves — Thu, 14 Dec 2023 16:16:34 +0000

Os testes unitários desempenham um papel crucial no desenvolvimento de software, garantindo que cada parte do código funcione conforme o esperado. Em projetos Laravel, onde a utilização de filas é comum para processamento em segundo plano, é essencial garantir que essas filas sejam testadas de forma adequada.

Vamos implementar testes na fila de sincronização de dados do projeto product-api.

jmgoncalves97 / product-api

Product API

Rode o composer install:

composer install

Após a instalação, o script ./init.sh será chamado para:

Instalar o MySQL
Criar o banco usado pela API.
Criar no banco o usuário utilizado pela API.
Rodar as migrações.
Gerar o swaager.json
Rodar os testes.
Startar a aplicação.

About Laravel

Simple, fast routing engine.
Powerful dependency injection container.
Multiple back-ends for session and cache storage.
Expressive, intuitive database ORM.
Database agnostic schema migrations.
Robust background job processing.
Real-time event broadcasting.

Laravel is accessible, powerful, and provides tools required for large, robust applications.

Learning Laravel

Laravel has the most extensive and thorough documentation and video…

View on GitHub

Antes de começar, confira meu artigo onde explico como implementar o Laravel Queue em seu projeto, seguindo padrões para manter seu código testável.

Laravel Queue, uma poderosa alternativa de fila para projetos PHP

Jonathan Gonçalves ・ Nov 27

No meu caso, optei por criar os testes após a implementação da fila. Contudo, vale destacar que a abordagem inversa, onde os testes são criados antes da implementação, também é válida e pode ser adotada conforme a preferência em seu projeto.

Crie um novo teste com o comando artisan make:test. Para fins de organização, criarei meus testes dentro da pasta Plataform1, pois meu job faz sinc de produtos com esse módulo.

php artisan make:test Plataform1/ProductSyncTest

O primeiro método que vamos criar, será responsável por testar o despache do nosso job para a fila. Não estranhe o tamanho do nome do método, pois prefiro que seja descritivo e claro em relação à sua funcionalidade.

Vamos usar umaQueue fake para testar os despaches e vamos despachar os jobs.

        Queue::fake();

        $productSync = new ProductSync();

        $queue = 'data_sync';

        ProductSyncJob::dispatch($productSync)->onQueue($queue);

Agora, verificaremos se ProductSyncJob foi despachado para data_sync.

Queue::assertPushedOn($queue, ProductSyncJob::class);

Vamos despachar mais dois jobs e fazer uma nova afirmação.

        Queue::bulk([
            new ProductSyncJob($productSync),
            new ProductSyncJob($productSync),
        ], '', $queue);

        Queue::assertPushed(ProductSyncJob::class, 3);

Caso você implemente o despache de jobs com o facade Bus, também poderá testa-lo.

        Bus::fake();

        Bus::batch([
            new ProductSyncJob($productSync),
            new ProductSyncJob($productSync),
        ])->onQueue($queue)->dispatch();

        Bus::assertBatched(function (PendingBatchFake $batch) {
            return count($batch->jobs) === 2;
        });

A implementação do nosso primeiro teste ficará assim.

<?php

namespace Tests\Feature\Plataform1;

use App\Jobs\Plataform1\ProductSyncJob;
use App\Services\Plataform1\ProductSync;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Illuminate\Support\Facades\Bus;
use Illuminate\Support\Facades\Queue;
use Illuminate\Support\Testing\Fakes\PendingBatchFake;
use Tests\TestCase;

class ProductSyncTest extends TestCase
{
    public function test_dispatching_the_product_sync_job_to_the_queue(): void
    {
        Queue::fake();

        $productSync = new ProductSync();

        $queue = 'data_sync';

        ProductSyncJob::dispatch($productSync)->onQueue($queue);

        Queue::assertPushedOn($queue, ProductSyncJob::class);

        Queue::bulk([
            new ProductSyncJob($productSync),
            new ProductSyncJob($productSync),
        ], '', $queue);

        Queue::assertPushed(ProductSyncJob::class, 3);

        Bus::fake();

        Bus::batch([
            new ProductSyncJob($productSync),
            new ProductSyncJob($productSync),
        ])->onQueue($queue)->dispatch();

        Bus::assertBatched(function (PendingBatchFake $batch) {
            return count($batch->jobs) === 2;
        });
    }
}

Você pode ajustar o teste de acordo com a necessidade do seu projeto, Laravel é um framework altamente testável e rico em recursos de teste.

Agora, vamos criar um teste chamado test_product_sync para o serviço ProductSync que injetamos em ProductSyncJob. Conhecer a implementação de ProductSync é fundamental para o entendimento do próximo teste. Você pode verificar sua implementação no artigo ou repositório mencionado anteriormente.

Vamos pegar a url que recebe as requisições e criar dois arrays de produtos.

        $plataform1Url = config('integration.plataform1')['api']['url'];

        $data1 = Plataform1Product::factory()
            ->count(10)
            ->make()
            ->toArray();

        $data2 = Plataform1Product::factory()
            ->count(10)
            ->make()
            ->toArray();

Agora, criaremos uma closure que retornará nosso response baseado nos parâmetros.

        $json = fn ($page, $nextPage) => [
            'next_page' => $nextPage,
            'data' => match ($page) {
                1 => $data1,
                2 => $data2,
            }
        ];

Então, vamos mockar os requests recebidos no endpoint, instanciar ProductSync e chamar o método execute.

        Http::fake([
            $plataform1Url.'/v1/products?page=1' => Http::response($json(1, 2)),
            $plataform1Url.'/v1/products?page=2' => Http::response($json(2, null)),
        ]);

        $productSync = new ProductSync();

        $productSync->execute();

Faremos três afirmações, que nossa tabela de produto tem um produto de $data1, um produto de $data2 e que após truncar, o produto estará ausente.

        $this->assertDatabaseHas('product', ['id' => $data1[0]['id']]);

        $this->assertDatabaseHas('product', ['id' => $data2[0]['id']]);

        Product::truncate();

        $this->assertDatabaseMissing('product', ['id' => $data1[0]['id']]);

A implementação do nosso segundo teste ficará assim.

    public function test_product_sync(): void
    {
        $plataform1Url = config('integration.plataform1')['api']['url'];

        $data1 = Plataform1Product::factory()
            ->count(10)
            ->make()
            ->toArray();

        $data2 = Plataform1Product::factory()
            ->count(10)
            ->make()
            ->toArray();

        $json = fn ($page, $nextPage) => [
            'next_page' => $nextPage,
            'data' => match ($page) {
                1 => $data1,
                2 => $data2,
            }
        ];

        Http::fake([
            $plataform1Url.'/v1/products?page=1' => Http::response($json(1, 2)),
            $plataform1Url.'/v1/products?page=2' => Http::response($json(2, null)),
        ]);

        $productSync = new ProductSync();

        $productSync->execute();

        $this->assertDatabaseHas('product', ['id' => $data1[0]['id']]);

        $this->assertDatabaseHas('product', ['id' => $data2[0]['id']]);

        Product::truncate();

        $this->assertDatabaseMissing('product', ['id' => $data1[0]['id']]);
    }

Antes de executarmos os testes, realizaremos algumas configurações para que o teste utilize um banco SQLite em memória.

Em phpunit.xml adicione as seguintes variáveis.

        <env name="DB_CONNECTION" value="sqlite"/>
        <env name="DB_DATABASE" value=":memory:"/>

Dentro de nossa classe de teste, use a trait RefreshDatabase.

    use RefreshDatabase;

Finalmente, vamos rodar nossos testes.

php artisan test

// opcionalmente, você pode passar o caminho do arquivo que deseja testar
php artisan test path/to/file

Neste artigo, exploramos a importância dos testes em filas de projetos Laravel, destacando como eles fortalecem a confiabilidade das aplicações. Ao adotar práticas de teste eficazes, garantimos que a execução assíncrona e a gestão de filas sejam mais consistentes. A integração de testes sólidos contribui para a construção de sistemas mais resilientes em ambientes de produção.

Adicionando o Laravel Horizon em nosso projeto

Jonathan Gonçalves — Wed, 06 Dec 2023 16:55:50 +0000

O Laravel Horizon simplifica a escalabilidade e configuração dos trabalhadores de fila, proporcionando um painel intuitivo e eficiente para o gerenciamento de filas no Laravel. Com métricas essenciais como taxa de transferência, tempo de execução e falhas, o Horizon facilita o monitoramento do sistema de filas.

Vamos fazer um exemplo prático utilizando o projeto product-api como base.

jmgoncalves97 / product-api

Product API

Easily start application with docker.

docker compose up

About Laravel

Simple, fast routing engine.
Powerful dependency injection container.
Multiple back-ends for session and cache storage.
Expressive, intuitive database ORM.
Database agnostic schema migrations.
Robust background job processing.
Real-time event broadcasting.

Laravel is accessible, powerful, and provides tools required for large, robust applications.

Learning Laravel

Laravel has the most extensive and thorough documentation and video tutorial library of all modern web application frameworks, making it a breeze to get started with the framework.

You may also try the Laravel Bootcamp, where you will be guided through building a modern Laravel…

View on GitHub

Antes de prosseguir com o Laravel Horizon, é aconselhável possuir um bom entendimento sobre o uso de filas no Laravel.

Laravel Queue, uma poderosa alternativa de fila para projetos PHP | by Jonathan Gonçalves | Medium

Jonathan Gonçalves ・ Nov 27, 2023 ・
Medium

Assumindo que você já tenha um bom entendimento sobre Laravel Queue, vamos começar.

Instale o Horizon no projeto.

composer require laravel/horizon

Publique os assets.

php artisan horizon:install

Agora, modifique o arquivo recém-criado config/horizon.php, incluindo a fila data_sync no array queue.

    'defaults' => [
        'supervisor-1' => [
            'connection' => 'redis',
            'queue' => ['default', 'data_sync'],
            'balance' => 'auto',
            'autoScalingStrategy' => 'time',
            'maxProcesses' => 1,
            'maxTime' => 0,
            'maxJobs' => 0,
            'memory' => 128,
            'tries' => 1,
            'timeout' => 60,
            'nice' => 0,
        ],
    ],

A configuração atual atende aos jobs despachados para a fila data_sync. No entanto, se sua aplicação envia jobs mais extensos, pesados ou enfrenta picos de alta demanda, é aconselhável ajustar as configurações para otimizar o desempenho e garantir uma execução eficiente.

Imagine um cenário em que uma fila, lida com jobs demorados que podem levar até 5 minutos para processar.

Vamos configurar um novo supervisor para esse cenário.

        // example of a queue for processing long, heavy and high-demand jobs  
        'supervisor-2' => [
            'connection' => 'redis',
            'queue' => ['long_processing_jobs'],
            'balance' => 'auto',
            'autoScalingStrategy' => 'time',
            'maxProcesses' => 1,
            'maxTime' => 0,
            'maxJobs' => 0,
            'memory' => 128,
            'tries' => 3,
            'timeout' => 300,
            'nice' => 0,
        ],

Atenção para retry_after em config/queue.php, ele deve ser maior que o timeout definido no supervisor de config/horizon.php.

        'long_processing_jobs' => [
            'driver' => 'redis',
            'connection' => 'default',
            'queue' => 'long_processing_jobs',
            'retry_after' => 450,
            'block_for' => null,
            'after_commit' => false,
        ],

Vamos supor que durante picos de alta demanda, nossa fila de produção enfileira mais de 100 jobs em poucos minutos.

Para otimizar o desempenho da nossa fila, podemos ajustar os parâmetros maxProcesses e balanceMaxShift. Esses ajustes devem ser feitos considerando sempre os recursos disponíveis.

'environments' => [
    'production' => [
        'supervisor-2' => [
            'maxProcesses' => 20, // parallel processes
            'balanceMaxShift' => 4,
            'balanceCooldown' => 3,
            'tries' => 3,
        ],
    ],
],

Podemos iniciar o Horizon com o comando abaixo.

php artisan horizon

É recomendado o uso do Supervisor para gerenciar nosso processo do Horizon em produção, então vamos instala-lo.

sudo apt-get install supervisor

Agora vamos criar um arquivo de configuração em /etc/supervisor/conf.d/horizon.conf.

[program:horizon]
process_name=%(program_name)s
command=php /home/jonathan/repo/product-api/artisan horizon
autostart=true
autorestart=true
user=jonathan
redirect_stderr=true
stdout_logfile=/home/jonathan/repo/product-api/storage/logs/horizon.log
stopwaitsecs=3600

Altere command e stdout_logfile com o caminho da sua aplicação e user para seu usuario.

Crie o arquivo storage/logs/horizon.log dentro da sua aplicação.

Inicie o Supervisor.

// System V
sudo service supervisor start

// Systemd
sudo systemctl start supervisor

Você poderá ver o log do Horizon em storage/logs/horizon.log e o log do Supervisor em /var/log/supervisor/supervisord.log.

Com as filas e supervisores do Horizon configurados e o Supervisor gerenciando o processo do Horizon, vamos rodar nossa aplicação product-api.

PHP_CLI_SERVER_WORKERS=2 php artisan serve --port 8001

Vamos requisitar o endpoint que despacha o job de sinc de dados.

curl http://localhost:8001/api/v1/sync/plataform1/products

Podemos acessar o dashboard do Horizon para acompanhar tudo com métricas detalhadas em http://localhost:8001/horizon.

Você pode ajustar app/Providers/HorizonServiceProvider.php para que apenas usuários especificos vejam o dashboard em ambiente não local.

protected function gate(): void
{
    Gate::define('viewHorizon', function (User $user) {
        return in_array($user->email, [
            'jonathan@example.com',
        ]);
    });
}

Ao tentar acessar com qualquer outro usuário, o forbidden status é retornado.

Ao longo deste artigo, exploramos as vantagens do Laravel Horizon para simplificar a gestão de filas no Laravel, destacando métricas essenciais. Com o exemplo prático no projeto Product-API, aprendemos a otimizar a escalabilidade e configurar trabalhadores de fila de maneira eficiente.

Laravel Queue, uma poderosa alternativa de fila para projetos PHP

Jonathan Gonçalves — Mon, 27 Nov 2023 15:58:11 +0000

Ao desenvolver um aplicativo web, deparar-se com tarefas demoradas, como o processamento em lote, é comum. A análise e armazenamento de grandes conjuntos de dados, por exemplo, podem impactar negativamente a resposta do aplicativo durante uma solicitação web típica. O Laravel Queue surge como uma ferramenta valiosa nesse contexto, proporcionando uma abordagem eficiente para lidar com operações que consomem tempo.

O PHP, por sua natureza, não oferece suporte nativo a paralelismo eficiente, o que pode ser um obstáculo ao lidar com tarefas intensivas. No entanto, o Laravel Queue contorna essa limitação ao permitir a execução assíncrona de tarefas em filas.

Considere um cenário em que você precisa processar grandes conjuntos de dados em lote, como a atualização de informações em massa. Em vez de sobrecarregar a solicitação web, o Laravel Queue permite enfileirar essas tarefas para execução em segundo plano.

Vamos criar um exemplo prático de um projeto que incorpora uma integração responsável por realizar a sincronização de produtos. Neste cenário, optaremos por aprimorar a eficiência do processo ao enviar o processamento dessa integração para a fila do Laravel.

Assumindo que você já tenha o PHP, Composer e um banco de dados relacional instalados em sua máquina, vamos começar.

Crie um projeto Laravel.

composer create-project laravel/laravel product-api

Aponte a sua base de dados no env.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=product_api
DB_USERNAME=root
DB_PASSWORD=

Em seguida, crie uma migration para sua tabela.

php artisan make:migration create_product_table

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('product', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('description', 1000)->nullable();
            $table->unsignedBigInteger('group_id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('product');
    }
};

php artisan migrate

Agora, crie uma classe de serviço para implementar o código responsável pela sincronização dos produtos. O Laravel não possui um comando para criar classe de serviço, mas você pode fazer manualmente.

<?php

namespace App\Services\Plataform1;

use App\Models\Product;
use Illuminate\Support\Facades\Http;

class ProductSync
{
    function execute()
    {
        $nextPage = 1;
        do {
            $body = $this->request($nextPage);

            $nextPage = $body['next_page'];

            $mappedData = collect($body['data'])->map(fn ($item) => Mapper::map($item))->all();

            $this->upsert($mappedData);
        }
        while ($nextPage != null);
    }

    /**
     * @return object{'data': array}
     */
    private function request($page = 1)
    {
        $plataform1 = config('integration.plataform1');

        try {            
            /**
             * @var \Illuminate\Http\Client\Response
             */
            $response = Http::withHeaders([
                'Authorization' => $plataform1['api']['token']
            ])->get($plataform1['api']['url'].'/v1/products', [
                'page' => $page
            ]);

            if ($response->status() != 200) {
                throw new ResponseStatusException($response->body(), $response->status());
            }

            return $response->json();
        }
        catch (\Throwable $th) {
            throw $th;
        }
    }

    private function upsert($data)
    {
        $chunks = array_chunk($data, 2000);

        /**
         * @var \Illuminate\Database\Eloquent\Builder
         */
        $Product = Product::class;

        foreach ($chunks as $chunk) {
            $Product::upsert(
                $chunk,
                ['id'],
                array_keys(reset($chunk))
            );
        }
    }
}

class Mapper {
    static function map($product) : array {
        return [
            'id' => $product['id'],
            'name' => $product['name'],
            'description' => $product['description'],
            'group_id' => $product['group_id'],
        ];
    }
}

class ResponseStatusException extends \Exception {}

Vamos criar um arquivo config/integration.php para adicionar configurações da integração.

<?php

return [
    'plataform1' => [
        'api' => [
            'url' => env('PLATAFORM1_URL', 'http://localhost:8001/plataform1/api'),
            'token' => env('PLATAFORM1_TOKEN')
        ]
    ]
];

Para simular o endpoint de produto da API, onde faremos as requisições, criaremos um novo módulo no projeto.

Adicione Modules e Modules\Plataform1\Database\Factories\ no composer.json

    "autoload": {
        "psr-4": {
            "App\\": "app/",
            "Database\\Factories\\": "database/factories/",
            "Database\\Seeders\\": "database/seeders/",
            "Modules\\": "app/Modules/",
            "Modules\\Plataform1\\Database\\Factories\\": "app/Modules/Plataform1/database/factories/"
        }
    },

Implemente o módulo Plataform1. Para testar o desempenho da nossa fila, mockaremos o retorno de 100 mil objetos. Em seguida, o serviço realizará a atualização dos dados em nosso banco.

<?php

namespace App\Modules\Plataform1\Http\Controllers;

use Illuminate\Http\Request;
use Modules\Plataform1\Models\Product;
use Illuminate\Routing\Controller;

class ProductController extends Controller {
    public function index(Request $request)
    {
        $page = $request->page ?? 1;

        $perPageDefault = pow(10, 4); // 10k

        $perPage = $request->per_page ?? $perPageDefault;

        $total = pow(10, 5); // 100k

        $pages = $total / $perPage;

        $data = Product::factory()
            ->count($perPage)
            ->make();

        $json = (object) [
            'next_page' => $page < $pages ? ++$page : null,
            'data' => $data
        ];

        return response()->json($json);
    }
}

<?php

namespace App\Modules\Plataform1\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureTokenIsValid
{
    /**
     * Handle an incoming request.
     * 
     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
     */
    public function handle(Request $request, Closure $next): Response
    {
        $token = $request->header('Authorization');

        if ($token == env('PLATAFORM1_TOKEN')) {
            return $next($request);
        }

        return response()->json(['error' => 'Token invalido'], 401);
    }
}

<?php

namespace Modules\Plataform1\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Modules\Plataform1\Database\Factories\ProductFactory;

class Product extends Model {

    protected $table = 'product';

    use HasFactory;

    protected static function newFactory() {
        return ProductFactory::new();
    }
}

<?php

namespace Modules\Plataform1\Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;
use Modules\Plataform1\Models\Product;

class ProductFactory extends Factory {
    protected $model = Product::class;

    public function definition()
    {
        return [
            'id' => $this->faker->unique()->numberBetween(1, pow(10, 5)), // 100k
            'name' => $this->faker->word,
            'description' => $this->faker->paragraph(),
            'group_id' => 1,
        ];
    }
}

<?php
use App\Modules\Plataform1\Http\Controllers\ProductController;
use App\Modules\Plataform1\Http\Middleware\EnsureTokenIsValid;

Route::prefix('plataform1/api/v1')->middleware([EnsureTokenIsValid::class])->group(function () {
    Route::get('/products', [ProductController::class,'index']);
});

Importe o routes.php do modulo Plataform1 em routes/web.php

require app_path('Modules').'/Plataform1/routes.php';

Agora, vamos configurar a fila e implementar os jobs que serão despachados para ela.

Instale a extensão predis.

composer require predis/predis

Adicione o Redis client e queue connection no env.

REDIS_CLIENT=predis
QUEUE_CONNECTION=redis

Em config/app.php, adicione um alias para o Redis.

'Redis' => Illuminate\Support\Facades\Redis::class,

Crie um job, injete o serviço responsavel pela sincronização dos produtos e chame o método execute.

php artisan make:job ProductSyncJob

<?php

namespace App\Jobs\Plataform1;

use App\Services\Plataform1\ProductSync;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class ProductSyncJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /**
     * Create a new job instance.
     * 
     *      */
    public function __construct(
        private ProductSync $productSync
    ) {}

    /**
     * Execute the job.
     * 
     *      */
    public function handle(): void
    {
        $this->productSync->execute();
    }
}

Agora, vamos criar um endpoint que será responsável pelo despache dos jobs.

<?php

namespace App\Http\Controllers;

use App\Services\Plataform1\ProductSync;
use Illuminate\Support\Facades\Redis;
use App\Http\Controllers\Controller;
use App\Jobs\Plataform1\ProductSyncJob;

class ProductSyncController extends Controller
{
    function __construct(
        private ProductSync $productSync
    ) {}

    public function index()
    {
        ProductSyncJob::dispatch($this->productSync)->onQueue('data_sync');

        return response()->json([
            'message' => 'Sincronização de produtos da Plataform1 iniciada'
        ]);
    }
}

<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\ProductSyncController;

Route::prefix('v1')->group(function () {
    Route::get('/sync/plataform1/products', [ProductSyncController::class,'index']);
});

Agora, configuraremos nossa fila. Esta etapa é crucial, e é recomendável ter um entendimento claro dos jobs que serão despachados para montar a configuração. No nosso cenário, usaremos a seguinte configuração.

'data_sync' => [
    'driver' => 'redis',
    'connection' => 'default',
    'queue' => 'data_sync',
    'retry_after' => 90,
    'block_for' => null,
    'after_commit' => false,
],

Finalmente, execute a aplicação para despachar os jobs na fila. Como o servidor de desenvolvimento local padrão não suporta requisições simultâneas, inicie com dois server workers.

PHP_CLI_SERVER_WORKERS=2 php artisan serve --port 8001

Inicie a fila.

php artisan queue:work data_sync

Agora, faça duas requisições ao endpoint que despacha o job de sincronização de produtos na fila. A primeira será para popular a tabela, e a segunda para testar o desempenho na atualização dos registros.

curl http://localhost:8001/api/v1/sync/plataform1/products

E voilà, nosso job atualizou 100 mil registros em apenas 11s, tudo isso consumindo baixissímo processamento.

Muito bacana, né?!

Se quiser, fique à vontade para clonar o repositório com essa implementação e brincar.

git clone git@github.com:jmgoncalves97/product-api.git

Ao longo deste artigo, exploramos a eficácia do Laravel Queue no aprimoramento de projetos PHP, destacando a importância de mover tarefas demoradas para segundo plano por meio de filas. Exemplificamos sua aplicação em uma integração de API externa, demonstrando como essa abordagem pode significativamente melhorar a responsividade do aplicativo.

DEV Community: Jonathan Gonçalves

Automatizando fluxos de trabalho com GitHub Actions

jmgoncalves97 / product-api

Product API

About Laravel

Learning Laravel

Testando filas em projetos Laravel

jmgoncalves97 / product-api

Product API

About Laravel

Learning Laravel

Laravel Queue, uma poderosa alternativa de fila para projetos PHP

Jonathan Gonçalves ・ Nov 27

Adicionando o Laravel Horizon em nosso projeto

jmgoncalves97 / product-api

Product API

About Laravel

Learning Laravel

Laravel Queue, uma poderosa alternativa de fila para projetos PHP | by Jonathan Gonçalves | Medium

Jonathan Gonçalves ・ Nov 27, 2023 ・ Medium

Laravel Queue, uma poderosa alternativa de fila para projetos PHP

Jonathan Gonçalves ・ Nov 27, 2023 ・
Medium