Como utilizar o Laravel para a recolha de dados na Web?

Com Laravel, podes extrair dados de um site em três passos: instalar um pacote como Symfony DomCrawler via Composer, criar uma encomenda Artisan, e, em seguida, selecionar os elementos HTML com seletores CSS.

Este guia sobre web scraping mostra-te como fazê-lo na prática, com código PHP pronto a usar.

Pré-requisitos para o scraping com Laravel

Laravel é um Estrutura PHP concebido para aplicações web modernas. O seu ecossistema abrangente torna-o uma base ideal para organizar um projeto de scraping limpo e fácil de manter.

Antes de começares, certifica-te de que tens o ambiente adequado:

• Composer, o gestor de dependências para instalar os pacotes.
• Uma versão recente de PHP compatível com a tua versão do Laravel.
• Laravel instalado através de composer create-project laravel/laravel o-meu-scraper.

No que diz respeito às competências, basta ter alguns conhecimentos básicos para começar:

• Conhecer os fundamentos de PHP e a estrutura de uma aplicação Laravel (controladores, estradas, arquitetura MVC).
• Compreender o HTML e a Seletores CSS para selecionar com precisão os elementos de uma página.
• Saber utilizar Composer na linha de comandos para adicionar um pacote ao projeto.

Quanto ao próprio rastreio, eis os ferramentas de raspagem os mais úteis:

• Symfony DomCrawler + HttpClient : a dupla de referência atualmente. Ele descarrega uma página e navega pelo HTML através do método filter() a partir de DomCrawler. Para inicializar o cliente, utiliza-se HttpClient::create() com as opções pretendidas.
• HTTP Client do Laravel : com base em Guzzle, recupera um conteúdo simples com Http::get() e gere bem as chamadas para uma API.
• Puppeteer / Headless Chrome : um navegador sem interface, indispensável para extrair páginas cujo conteúdo é carregado em JavaScript ou através de Ajax.

Tutorial para criar o seu primeiro scraper com Laravel

Segue estes passos para criar um scraper funcional com Laravel. Vais instalar um pacote de scraping e gerar um comando Artisan, e, em seguida, selecionar os dados com seletores CSS.

Passo 1: Instalação e configuração

Cria um novo projeto Laravel com Composer, e depois acrescenta Goutte, uma integração prática para o scraping:

# 1) Criar um novo projeto Laravel
compose create-project laravel/laravel scraper-demo
cd scraper-demo

# 2) Adicionar Goutte (integração Laravel)
composer require weidner/goutte

Os pacotes weidner/goutte e fabpot/goutte foram hoje oficialmente abandonados. Ainda funcionam, mas, para um projeto novo, recomenda-se a sua substituição no que diz respeito a Symfony é symfony/browser-kit, em conjunto com symfony/http-client e symfony/dom-crawler. O código abaixo continua a ser válido se utilizares weidner/goutte, que simplesmente encapsula Goutte por Laravel.

Passo 2: Criar uma encomenda Artisan

Gera um comando que irá conter a tua lógica de scraping com php artisan :

php artisan make:command ScrapeData

O ficheiro é criado aqui : app/Console/Commands/ScrapeData.php. É nesta turma que vais escrever a solicitação HTTP e a extração dos dados. A classe ScrapeData estende-se Comando, e o método função pública handle() contém toda a lógica de scraping.

Passo 3: Escrever o código do raspador

No comando gerado, vais juntar três elementos essenciais:

• A Pedido HTTP para recuperar o conteúdo HTML da página.
• Do Seletores CSS passados para o DomCrawler para filtrar os dados através de filter().
• A laço para procurar os itens e apresentar os resultados.

Eis um exemplo de código completo para extrair os títulos de artigos de um blogue:

info('Extração: {$url}");

        // 1) Pedido HTTP para recuperar o HTML
 $crawler = Goutte::request("GET', $url);

        // 2) Utilização de seletores CSS com o DomCrawler
 $nodes = $crawler->filter('h2 a');

        // 3) Iteração sobre os elementos e visualização
 $nodes->each(function (Crawler $node, $i) {
 $title = $node->text();
            $link  = $node->attr('href');
 $this->line(($i+1) . '. " . $title . " - " . $link);
 });

 return self::SUCCESS;
    }
}

Aqui, DomCrawler faz todo o trabalho de análise do HTML. O método filter('h2 a') recupera cada link presente num título e, em seguida, each() loop para extrair o texto e o atributo href. Em seguida, executa o scraper a partir do teu terminal com php artisan scrape:data e verás os títulos a aparecerem um a um. Também podes iniciar php artisan serve para testares a tua aplicação localmente antes de a implementares.

Melhores práticas para a recolha de dados da Web com Laravel

Para fazer scraping de forma correta com o Laravel, alguns hábitos fazem toda a diferença. Aqui estão as boas práticas a aplicar, quer estejas a gerir um bot de web scraping ou uma encomenda pontual.

1. Gestão de tarefas e enfileiramento

O scraping pode demorar vários segundos por página. Imagina ter de fazer scraping 1000 páginas de um site: a tua aplicação ficaria bloqueada e inutilizável durante bastante tempo. A solução resume-se a duas palavras: os empregos e a filas do Laravel.

• UMA trabalho, é uma tarefa que queres executar em segundo plano.
• A cauda (fila de espera), é o local onde se armazenam essas tarefas para as executar gradualmente, sem bloquear o resto.

Eis como encapsular a lógica de scraping num trabalho:

// app/Jobs/ScrapePageJob.php
<?php

namespace App\Jobs;

use Goutte\Client; // Ou Guzzle/Http, selon ta stack
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

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

    protected string $url;

    public function __construct(string $url)
    {
        $this->url = $url;
    }

    função pública handle(): void
    {
        $client = new Client();

        $crawler = $client-&gt;request('GET', $this-&gt;url);

        // Exemplo simples: extrair tudo <h1>
        $titles = $crawler-&gt;filter('h1')-&gt;each(function ($node) {
            return $node-&gt;text();
        });

        // Persistência / registos / eventos...
        foreach ($titles as $title) {
            \Log::info("[Scraping] {$this-&gt;url} - H1: {$title}");
        }
    }
}

// app/Http/Controllers/ScraperController.php
onQueue('scraping'); // se quiseres uma fila dedicada
 }

 return response()->json(['status' => 'Scraping iniciado em segundo plano']);
    }
}

Para ativar este controlador, declare uma estrada no teu ficheiro routes/web.php Onde routes/api.php, por exemplo Route::get('/scrape', [ScraperController::class, 'start']). Também podes gerar um controlador dedicado com php artisan make:controller ScraperController.

O Laravel disponibiliza vários sistemas para gerir esta fila. Os dois mais utilizados são:

• Ficheiro com base de dados : as tarefas são armazenadas como linhas numa tabela SQL e, em seguida, executadas uma a uma por um worker.
• Vai com Redis : os trabalhos são colocados na memória numa fila ultrarrápida, ideal para um grande volume de tarefas.

2. Automatização com o agendador de tarefas do Laravel

O Laravel integra um planeador de tarefas (agendador) que te permite automatizar os teus scrapers sem teres de te preocupar com isso. Assim, podes agendar a execução de um comando a intervalos regulares, por exemplo a cada hora.

Eis como configurá-lo em app/Console/Kernel.php :

command('scraper:run')->hourly();

 // Exemplos úteis:
 // $schedule->command('scraper:run')->everyFifteenMinutes();
        // $schedule->command('scraper:run')->dailyAt('02:30')->timezone('Indian/Antananarivo');
    }

 /**
 * Registo de comandos.
     */
    protected function commands(): void
    {
 $this->load(__DIR__ . '/Commands');
    }
}

3. Contornar a proteção anti-raspagem

Muitos sites implementam medidas de proteção contra os scrapers. Para evitar ser bloqueado:

• Alterar o User-Agent : simula um navegador real, em vez do cabeçalho predefinido do cliente HTTP.
• Gestão de prazos : insere pausas (sleep, throttle) entre os pedidos, para não sobrecarregar o servidor de destino.
• Utilizar proxies : distribui os pedidos por vários endereços IP.

4. Respeitar o ficheiro robots.txt e o quadro jurídico

Contornar uma proteção não significa fazer o que bem entender. O scraping continua a estar sujeito a regras, e ignorá-las pode sair-te caro.

• Respeita o ficheiro robots.txt : indica as páginas que o site permite ou proíbe que sejam rastreadas. É a primeira regra de cortesia a seguir.
• Verifica as condições de utilização : um site pode proibir o scraping através dos seus Termos e Condições de Utilização.
• Lembra-te do RGPD : se recolheres dados pessoais, tens de respeitar o regulamento europeu relativo à recolha e ao tratamento desses dados.

Quais são as alternativas ao web scraping com Laravel?

O Laravel continua a ser prático para integrar o scraping numa aplicação PHP existente. Mas, dependendo do teu projeto, outras soluções podem, por vezes, ser mais adequadas. Aqui estão as duas principais alternativas, com as suas vantagens e limitações.

Web scraping com Python

Python é a linguagem mais utilizada para o scraping. Baseia-se em bibliotecas consolidadas como Scrapy e BeautifulSoup.

• Vantagens : ecossistema muito rico, gestão nativa do rastreamento em grande escala, comunidade enorme.
• Desvantagens : é preciso sair do universo Laravel. Não é muito prático se o teu site e a tua API já estiverem a funcionar em PHP.

Na prática, deves optar pelo Python se o scraping for o cerne do projeto, e não apenas um componente da tua aplicação.

Ferramentas sem código

Cada vez mais ferramentas permitem fazer scraping sem codificação, por vezes com a ajuda do’IA. Os mais conhecidos são Dados brilhantes, Octoparse e Apify.

• Vantagens : configuração visual, gestão de páginas em JavaScript e de bloqueios integrada, sem necessidade de escrever uma única linha de código.
• Desvantagens : subscrição paga, menos controlo preciso do que um scraper personalizado em Laravel.

Perguntas frequentes

Como é que eu faço scraping de um site protegido por login com Laravel?

O princípio é simples: simulas uma ligação e, em seguida, reutilizas a sessão para aceder às páginas protegidas. Concretamente, tens de:

1. Simular a ligação com um pedido POST que envia o e-mail e a palavra-passe para o formulário.
2. Manter os cookies de sessão para que os pedidos seguintes permaneçam autenticados.

Com o HttpBrowser do Symfony, podes executar as duas etapas de forma muito organizada. Ele instancia o cliente através de HttpClient::create(), e, em seguida, gere os cookies automaticamente entre cada pedido:

use Symfony\Component\BrowserKit\HttpBrowser;
use Symfony\Component\HttpClient\HttpClient;

$browser = new HttpBrowser(HttpClient::create());

$crawler = $browser->request('GET', 'https://exemple.com/login');
$form = $crawler->selectButton('Se connecter')->form();

$browser->submit($form, [
    'email'    => 'ton@email.com',
    'password' => 'ton_mot_de_passe',
]);

// Les cookies de session sont gardés automatiquement
$page = $browser->request('GET', 'https://exemple.com/compte');
echo $page->filter('h1')->text();

Nota: o HttpBrowser gere os cookies automaticamente entre duas solicitações. Por isso, não precisas de guardar nada manualmente.

Como é que se gere a paginação quando se faz web scraping com Laravel?

Para percorrer várias páginas seguidas, basta localizar o link “página seguinte” com um Seletor CSS, e depois repetir enquanto existir. Eis a lógica:

1. Raspar a primeira página e extrair os dados úteis.
2. Detetar o link “seguinte” através de um seletor CSS.
3. Fechar até que não haja mais nenhuma página seguinte.

$url = 'https://exemple.com/blog?page=1';

while ($url) {
    $crawler = $browser->request('GET', $url);

    $crawler->filter('.article-title')->each(function ($node) {
        echo $node->text() . PHP_EOL;
    });

    // Récupère le lien "page suivante" s'il existe
    $next = $crawler->filter('a.next');
    $url  = $next->count() ? $next->attr('href') : null;
}

Este ciclo termina automaticamente assim que o seletor a.next já não apresenta nenhum resultado.

Como exportar os dados recolhidos (para CSV, Excel ou JSON)?

Depois de recuperares os teus dados, podes exportá-los em vários formatos com o Laravel:

• fputcsv() para gerar um ficheiro CSV nativo.
• A livraria Maatwebsite\Excel para criar um ficheiro Excel.
• A função nativa json_encode() para exportação JSON, o que é útil se, posteriormente, divulgares os teus dados através de uma API.

Como gerir os erros e as excepções durante a recolha de dados?

Um site pode apresentar um erro, alterar a sua estrutura HTML ou interromper a ligação. Para criar um scraper robusto, deves antecipar estas situações:

1. Encapsular cada pedido em um try/catch.
2. Verificar os códigos HTTP (404, 429, 500…) e registar o erro ou repetir a tentativa após um certo intervalo.

try {
    $crawler = $browser->request('GET', $url);
    $status  = $browser->getResponse()->getStatusCode();

    if ($status !== 200) {
        \Log::warning("Réponse inattendue: $status sur $url");
    }
} catch (\Exception $e) {
    \Log::error('Scraping échoué: ' . $e->getMessage());
}

A raspagem da Web é legal ou ilegal?

o legalidade da recolha de dados na Web depende do site em questão e da forma como utilizas os dados. Eis os três pontos a ter em conta:

• Direito sui generis sobre as bases de dados a Diretiva Europeia 96/9/CE protege o conteúdo de uma base de dados. A extração de uma parte significativa de um site pode ser proibida.
• Termos e condições de utilização : a decisão Ryanair contra a PR Aviation (TJUE, 2015) confirmou que um site pode proibir o scraping nas suas condições gerais de utilização, mesmo na ausência de proteção ao abrigo do direito de autor.
• RGPD : assim que recolheres dados pessoais (e-mails, nomes, perfis), estás sujeito ao regulamento europeu. É preciso ter o máximo de cuidado.

Na prática, respeita sempre o ficheiro robots.txt, limita a frequência das tuas consultas e evita o tratamento de dados pessoais sem fundamento jurídico. Tens alguma dúvida ou um caso específico? Deixa o teu comentário.