Instalando e configurando o Puppeteer: resolvendo problemas comuns de dependência e Chromium

Índice

Instalando e configurando o Puppeteer: resolvendo problemas comuns de dependência e Chromium

Quer automatizar o Chrome ou o Chromium com facilidade? Marionetista é um Node.js biblioteca que simplifica a automação do navegador, perfeita para tarefas como testes e scraping. Aqui está o que você aprenderá:

Integração direta no Latenode: Saiba como Nó latente melhora os fluxos de trabalho de raspagem da web com um integração direta com o Headless Browser baseado em Puppeteer e recursos amigáveis à automação. Não há necessidade de pré-configurar nada, basta adicionar o nó e usar na automação do fluxo de trabalho!
Requisitos de configuração: Use o Node.js 18+ e garanta que seu sistema atenda às dependências específicas do sistema operacional.
Opções de instalação: Instale o Puppeteer com npm i puppeteer (inclui Chrome para teste) ou npm i puppeteer-core (use seu próprio navegador).
Dicas de solução de problemas: Corrigir erros de inicialização do Chromium, bibliotecas ausentes e conflitos de dependência.
Configurações Avançadas: Otimize o desempenho, configure proxies e gerencie variáveis de ambiente.

Antes de compartilharmos um guia completo sobre problemas na configuração do Puppeteer, você deve saber que pode simplesmente pular isso e usar um nó de integração direto e pronto no Latenode! Confira:

Pular a configuração do Puppeteer: use nossa integração pronta para uso em Nó latente

O Latenode funciona perfeitamente com o Puppeteer para simplificar a automação do navegador. Abaixo, exploraremos os recursos do Latenode e como usar uma integração direta com o Puppeteer para suas necessidades de automação.

Aqui está uma análise dos principais recursos do Latenode:

Característica	Descrição	Beneficiar
Navegador sem cabeça	Integração da biblioteca Puppeteer	Controle direto do navegador
Assistente de código AI	Geração automatizada de código	Acelera a depuração e a codificação
Flexibilidade sem código	Mais de 300 integrações sem código para ajustes de fluxo de trabalho personalizados	Estende a funcionalidade do Puppeteer
Suporte ao pacote NPM	Acesso a mais de 1 milhão de pacotes	Aumenta as capacidades de automação

"O que mais gostei no Latenode em comparação com a concorrência é que eu tinha a capacidade de escrever código e criar nós personalizados." - Germaine H., Fundadora de Tecnologia da Informação

Nó latente Ferramentas

Nó latente

O Latenode oferece integração com o nó Headless Browser, que é baseado no Puppeteer e permite que você adicione código diretamente no editor e o use para tarefas como extrair todas as informações disponíveis de um site, fazer capturas de tela de páginas, preencher formulários e, em geral, qualquer coisa suportada pelo Puppeteer.

Para encontrar essa integração, basta navegar até a pasta Code Integrations na biblioteca de nós, onde você encontrará o nó Headless Browser. Adicione-o ao seu script, clique nele e um editor será aberto, onde você pode adicionar código de qualquer complexidade e comprimento. Além disso, você pode especificar o endereço, login e senha do seu Proxy nas configurações.

Conectando o navegador headless baseado em Puppeteer a outras integrações

Mas um nó não é suficiente para automação. Para maior personalização, adicione um gatilho e outra ação. Por exemplo, um gatilho e resposta de webhook para monitorar mudanças na taxa de câmbio no Banco da Inglaterra, como mostramos no guia acima. Aqui está um cenário:

CENÁRIO

Por que escolher a integração Latenode em vez da solução baseada em VPS?

"O Latenode supera a concorrência com 99% de tempo de atividade, preços acessíveis com base na execução e uma interface amigável." - Hammad Hafeez

O preço do Latenode é baseado no tempo de execução em vez de tarefas individuais, tornando-o uma opção econômica para automação de Puppeteer em larga escala. Esta plataforma permite que os desenvolvedores se concentrem na criação de fluxos de trabalho robustos sem se preocupar com custos excessivos.

Para maximizar a eficiência, você pode usar a integração com Javascript do Latenode, além de mais de 300 integrações com banco de dados, CRM, ferramentas de gerenciamento de projetos e modelos de IA como Claude, ChatGPT e Gemini. Existem muitos casos de uso potenciais: divulgação automatizada, gerenciamento de banco de dados, web scraping, etc. Ao combinar Latenode e Puppeteer, você pode centralizar e agilizar seus processos de automação.

Se você ainda quiser um guia sobre como corrigir problemas do Puppeteer, confira a análise abaixo.

Falha ao iniciar o Chromium no VPS? Instale as dependências ausentes no VPS puppetter

Antes que você comece

Antes de instalar o Puppeteer, certifique-se de que sua configuração atende às dependências necessárias para garantir uma instalação e operação tranquilas.

Node.js instalação

Node.js

O marionetista requer Node.js para executar. As versões mais recentes do Puppeteer funcionam com Versão do Node.js 18 ou superior, que se alinha com a versão atual do LTS.

Para verificar sua versão do Node.js, use este comando:

node --version

Se sua versão for inferior a 18, atualize o Node.js antes de continuar. É altamente recomendável usar a versão LTS mais recente. Após confirmar sua versão do Node.js, verifique os requisitos do sistema operacional do seu sistema.

Requerimentos do sistema

Os requisitos de sistema para o Puppeteer dependem do sistema operacional que você está usando. Aqui está uma rápida visão geral:

Sistema Operacional	Arquitetura	Componentes Requeridos	Tamanho aproximado do download
Windows	x64	Chrome para teste	~ 280 MB
MacOS	x64, braço64	Chrome para teste	~ 170 MB
Debian / Ubuntu	x64	Chrome para testes + bibliotecas	~ 282 MB

Ao instalar o Puppeteer, ele baixará automaticamente uma versão compatível do Chrome para testes. O tamanho do download varia dependendo do seu sistema operacional (~280 MB para Windows, ~170 MB para macOS e ~282 MB para Debian/Ubuntu Linux). .

Para usuários Linux, particularmente no Debian/Ubuntu, você precisará instalar algumas bibliotecas adicionais. Use o seguinte comando:

apt-get install -y libx11-xcb1 libxcomposite1 libxcursor1 libxdamage1 libxi6 libxtst6 libnss3 libcups2 libxss1 libxrandr2 libasound2 libatk1.0-0 libgtk-3-0

Aqui estão algumas dicas extras para ambientes específicos:

AWS EC2 Amazon Linux: Habilite o repositório EPEL e instale o Chromium antes de configurar o Puppeteer.
Ambientes Docker: Adicione as bibliotecas compartilhadas necessárias e o pacote Chromium ao seu Dockerfile.
TypeScript Projetos: Usar TypeScript versão 4.7.4 ou superior para acessar as definições de tipo mais recentes do Puppeteer e melhorar o suporte do IDE.

Etapas básicas de instalação

Depois de confirmar a configuração do Node.js e os requisitos do sistema, você pode instalar o Puppeteer usando o npm.

Guia de instalação do npm

Você tem duas maneiras de instalar o Puppeteer através do npm:

Instalação Padrão: Esta opção baixa automaticamente o Chrome para teste:
```
npm i puppeteer
```
Instalação do núcleo: Use isto se quiser gerenciar navegadores separadamente e pular o download do Chrome para testes:
```
npm i puppeteer-core
```

Com a instalação padrão, o Chrome para testes e o chrome-headless-shell binários são baixados para $HOME/.cache/puppeteer. Verifique a seção Requisitos do sistema para obter detalhes sobre os tamanhos de download.

Depois de instalado, você estará pronto para testar sua configuração.

Testando sua configuração

Comece criando um arquivo chamado test.js e adicione o seguinte script:

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://www.google.com');
  console.log('Page title:', await page.title());
  await browser.close();
})();

Execute o script com:

node test.js

Se o script for executado com sucesso e exibir o título da página, sua instalação está funcionando corretamente.

Dicas de solução de problemas

Usuários Linux: Use seu gerenciador de pacotes para garantir que todas as dependências necessárias estejam instaladas.
Usuários do Windows: Verifique se as permissões do sandbox do Chrome estão configuradas corretamente.
Se o Chrome não for encontrado em seu local padrão, defina o PUPPETEER_CACHE_DIR variável de ambiente para apontar para o diretório de instalação correto.

"Correr sem uma caixa de areia é fortemente desencorajado. Considere configurar uma sandbox."

Para melhor estabilidade e manutenção mais fácil, você pode criar um .puppeteerrc.cjs arquivo para configurar o comportamento do Puppeteer em vez de passar argumentos diretamente para o launch método.

Corrigindo problemas do Chromium

Problemas com o Chromium geralmente decorrem de bibliotecas ausentes ou configurações incorretas.

Usando Chromium local

Se você preferir usar uma instalação existente do Chromium em vez de baixar uma nova, o Puppeteer pode ser configurado para funcionar com seu navegador local. Este método é útil se você precisa de uma versão específica do Chromium ou lida com instalações de navegador manualmente.

Para vincular o Puppeteer ao seu Chromium local, ajuste suas configurações de inicialização assim:

const browser = await puppeteer.launch({ executablePath: '/usr/bin/chromium-browser' });

Certifique-se de que todas as bibliotecas necessárias estejam instaladas. No Linux, você pode identificar bibliotecas ausentes com:

ldd chrome | grep not

Se usar uma instalação local não for uma opção, considere instalar o Chromium separadamente seguindo as etapas abaixo.

Instalando o Chromium separadamente

A partir do Puppeteer v20.0.0, o Chrome para testes é baixado em vez do Chromium.

Visão geral de compatibilidade:

Versão do marionetista	Versão do navegador	Tamanho do Download
v24.4.0	Chrome para teste 134.0.6998.35	~170 MB (macOS)
v24.3.1	Chrome para teste 133.0.6943.141	~282 MB (Linux)
v24.3.0	Chrome para teste 133.0.6943.126	~280 MB (Windows)

Se você encontrar o erro "Falha ao iniciar o Chrome", tente estas correções:

Verificar dependências: Instale quaisquer bibliotecas ausentes em sistemas baseados em Debian:
```
sudo apt-get install -y libasound2 libatk1.0-0 libgbm-dev
```
Ajustar as configurações de memória: Para ambientes Docker, aumente /dev/shm tamanho ou usar o --disable-dev-shm-usage bandeira:
```
const browser = await puppeteer.launch({
  args: ['--disable-dev-shm-usage']
});
```
Definir tempos limite de navegação: Evite travamentos definindo um tempo limite de navegação personalizado, como 60 segundos:
```
await page.setDefaultNavigationTimeout(60000); // 60 seconds
```

"O chrome(-ium) sem cabeça precisa de muitas dependências para funcionar, e o puppeteer não instala todas elas." - savebreach.com

Para ambientes como o GitLab CI ou casos em que o sandbox está desabilitado (não recomendado), inclua argumentos de inicialização específicos:

const browser = await puppeteer.launch({
  args: ['--no-sandbox', '--disable-setuid-sandbox']
});

Para ignorar avisos relacionados a HTTPS em versões recentes do Chrome, desative o recurso HttpsFirstBalancedModeAutoEnable:

const browser = await puppeteer.launch({
  args: ['--disable-features=HttpsFirstBalancedModeAutoEnable']
});

Manipulando Dependências

Gerenciar dependências efetivamente é crucial para evitar falhas de inicialização e comportamento imprevisível. Esta seção aborda a resolução de conflitos de versão e a manutenção de pacotes atualizados para evitar erros de tempo de execução.

Corrigindo conflitos de pacotes

Conflitos de pacotes geralmente levam a erros como "Não é possível encontrar o módulo 'puppeteer-core/internal/...'" ou problemas de inicialização do Chrome. Veja como resolver esses problemas:

// Example: Resolving version conflicts using package.json overrides
{
  "overrides": {
    "ws": "^8.17.1",
    "debug": "^4.3.4"
  }
}

Etapas para solucionar problemas:

Verifique a versão do Node.js: Certifique-se de que você está usando o Node.js 18 ou superior. Versões mais antigas podem levar a problemas de compatibilidade.
Verificar bibliotecas do sistema: No Linux, certifique-se de que todas as bibliotecas de sistema necessárias estejam instaladas. Consulte a lista de dependências na seção Requisitos do Sistema.
Revisar as políticas do Chrome: As políticas do Chrome podem entrar em conflito com o padrão do Puppeteer --disable-extensions bandeira. Tente iniciar sem ela:

const browser = await puppeteer.launch({
  ignoreDefaultArgs: ['--disable-extensions']
});

Depois que os conflitos forem resolvidos, atualize seus pacotes para garantir estabilidade contínua.

Mantendo os pacotes atualizados

Atualizar dependências regularmente reduz riscos de segurança e garante compatibilidade. Veja como gerenciar esse processo:

Dependências de trilha

Use uma tabela simples para monitorar versões de pacotes, datas de atualização e sua importância:

Pacote	Versão atual	Ultima atualização	Solicitado por
titereiro	24.4.0	Mar 2024	Funcionalidade central
ws	8.17.1	fevereiro 2024	Suporte WebSocket
depurar	4.3.4	Jan 2024	Sistema de registro

Gerenciamento de versão

Ao atualizar, use intervalos de versionamento semânticos com cuidado. Para dependências críticas, fixe versões exatas para evitar alterações inesperadas:

{
  "dependencies": {
    "puppeteer": "24.4.0",
    "puppeteer-core": "24.4.0"
  }
}

Atualizações de solução de problemas

Gere um relatório de dependência detalhado com:

npm list --all > dependency-report.txt

Este relatório ajuda a identificar conflitos e dependências aninhadas problemáticas.

Para ambientes como Docker ou GitLab CI, certifique-se de que sua configuração inclua os pacotes de sistema necessários:

RUN apt-get update && apt-get install -y \
    chromium \
    libnss3 \
    libgconf-2-4 \
    libxss1

Configurações extras

Ajuste o Puppeteer para configurações avançadas com essas configurações adicionais.

variáveis ambientais

Variáveis de ambiente permitem que você ajuste o comportamento do Puppeteer e substitua as configurações padrões.

Aqui estão algumas variáveis-chave:

Variável	Propósito	Valor de exemplo
DIRETÓRIO_CACHE_DO_MARIONEIRO	Especifica um diretório de cache personalizado para downloads do navegador	/usr/local/cache/marionetista
CAMINHO_EXECUTIVO_DO_MARIONETARIO	Aponta para um executável específico do navegador	/usr/bin/cromo
PROXY HTTP	Configura as configurações do proxy HTTP	http://proxy.company.com:8080
https_proxy	Configura as configurações de proxy HTTPS	https://proxy.company.com:8443
NO_PROXY	Lista domínios excluídos do uso de proxy	host local,127.0.0.1

Para instalações personalizadas do Chromium, defina o caminho do executável assim:

const browser = await puppeteer.launch({
  executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || puppeteer.executablePath()
});

Depois que as variáveis de ambiente forem definidas, você poderá configurar proxies para lidar com restrições de rede de forma eficaz.

Configuração de proxy

Para usar um servidor proxy com o Puppeteer, aplique a seguinte configuração:

// Launch Puppeteer with a proxy server and authentication
const browser = await puppeteer.launch({
  args: ['--proxy-server=http://157.230.255.230:8118']
});

await page.authenticate({
  username: 'proxyUser',
  password: 'proxyPass'
});

// Optimize navigation with specific settings
await page.goto('https://example.com', {
  waitUntil: 'networkidle2',
  timeout: 30000
});

Inclua tratamento de erros para garantir desempenho robusto na produção:

try {
  await page.goto(url);
} catch (error) {
  console.error('Proxy connection failed:', error.message);
  // Add fallback logic or retry mechanism
}

Para configurações corporativas, exporte as configurações de proxy no seu terminal:

export HTTP_PROXY="http://proxy.company.com:8080"
export HTTPS_PROXY="https://proxy.company.com:8443"
export NO_PROXY="localhost,127.0.0.1,.company.internal"

Você também pode validar conexões proxy programaticamente:

const validateProxy = async (page) => {
  try {
    await page.goto('https://api.ipify.org?format=json');
    const content = await page.content();
    return content.includes('ip');
  } catch {
    return false;
  }
};

Isso garante que sua configuração de proxy esteja funcionando corretamente antes de prosseguir.

Próximos passos

Lista de verificação de configuração

Antes de começar com a automação do Puppeteer, certifique-se de que seu ambiente esteja configurado corretamente. Use o script abaixo para validar sua configuração:

// Validation script for environment setup
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.validateEnvironment();  // Custom validation
await browser.close();

Componente de configuração	Etapa de verificação	Problema comum
Node.js	Verifique a compatibilidade da versão	Versão desatualizada do Node.js
Pacote.json	Verifique a entrada "tipo": "módulo"	Erros de importação ES6
Instalação do Chrome	Teste de lançamento do navegador	Binário Chromium ausente
Configurações de memória	Verifique o tamanho /dev/shm no Docker	Falha do navegador ao iniciar
Gestão de Recursos	Implementar browser.close()	Perda de memória

Depois que sua configuração for verificada, você pode se concentrar em melhorar seus fluxos de trabalho para obter melhores resultados de automação.

Dicas de Primeiros Passos

CarriyoO sistema PDF da 's processou com eficiência 10,000 etiquetas de remessa diariamente, atingindo uma latência p95 de 365 ms Para atingir níveis de desempenho semelhantes, considere estas estratégias:

Gestão de Recursos: Desabilite recursos desnecessários para economizar recursos. Por exemplo, inicie o Puppeteer com configurações otimizadas:

const browser = await puppeteer.launch({
  headless: true,
  args: ['--disable-dev-shm-usage'],
  defaultViewport: { width: 1920, height: 1080 }
});

Tratamento de erros: Use métodos robustos de recuperação de erros, como blocos try-catch e manipuladores de erros personalizados, adaptados a problemas específicos.
Otimização de performance: Aumente a velocidade por:
- Armazenando em cache dados usados com frequência
- Interceptando solicitações de rede
- Executando tarefas em paralelo
- Usando o Chrome DevTools para monitorar o desempenho

Para uma automação mais avançada, explore a plataforma de fluxo de trabalho low-code da Latenode. Ela oferece preços baseados em execução e uma variedade de recursos para simplificar implementações complexas do Puppeteer. .