Instalando e configurando o Puppeteer: resolvendo problemas comuns de dependência e Chromium
Aprenda como instalar e configurar o Puppeteer para automação de navegadores, solucionar problemas comuns e otimizar sua configuração para obter melhor desempenho.
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) ounpm 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
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.
sbb-itb-23997f1
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
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 | Plataforma | 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 puppeteerInstalaçã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:
<span class="hljs-keyword">const</span> puppeteer = <span class="hljs-built_in">require</span>(<span class="hljs-string">'puppeteer'</span>);
(<span class="hljs-title function_">async</span> () => {
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>();
<span class="hljs-keyword">const</span> page = <span class="hljs-keyword">await</span> browser.<span class="hljs-title function_">newPage</span>();
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">goto</span>(<span class="hljs-string">'https://www.google.com'</span>);
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">'Page title:'</span>, <span class="hljs-keyword">await</span> page.<span class="hljs-title function_">title</span>());
<span class="hljs-keyword">await</span> browser.<span class="hljs-title function_">close</span>();
})();
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_DIRvariá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:
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({ <span class="hljs-attr">executablePath</span>: <span class="hljs-string">'/usr/bin/chromium-browser'</span> });
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:
<span class="hljs-built_in">sudo</span> apt-get install -y libasound2 libatk1.0-0 libgbm-devAjustar as configurações de memória: Para ambientes Docker, aumente
/dev/shmtamanho ou usar o--disable-dev-shm-usagebandeira:<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({ <span class="hljs-attr">args</span>: [<span class="hljs-string">'--disable-dev-shm-usage'</span>] });Definir tempos limite de navegação: Evite travamentos definindo um tempo limite de navegação personalizado, como 60 segundos:
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">setDefaultNavigationTimeout</span>(<span class="hljs-number">60000</span>); <span class="hljs-comment">// 60 seconds</span>
"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:
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
<span class="hljs-attr">args</span>: [<span class="hljs-string">'--no-sandbox'</span>, <span class="hljs-string">'--disable-setuid-sandbox'</span>]
});
Para ignorar avisos relacionados a HTTPS em versões recentes do Chrome, desative o recurso HttpsFirstBalancedModeAutoEnable:
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
<span class="hljs-attr">args</span>: [<span class="hljs-string">'--disable-features=HttpsFirstBalancedModeAutoEnable'</span>]
});
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:
<span class="hljs-comment">// Example: Resolving version conflicts using package.json overrides</span>
{
<span class="hljs-string">"overrides"</span>: {
<span class="hljs-string">"ws"</span>: <span class="hljs-string">"^8.17.1"</span>,
<span class="hljs-string">"debug"</span>: <span class="hljs-string">"^4.3.4"</span>
}
}
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-extensionsbandeira. Tente iniciar sem ela:
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
<span class="hljs-attr">ignoreDefaultArgs</span>: [<span class="hljs-string">'--disable-extensions'</span>]
});
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:
<span class="hljs-punctuation">{</span>
<span class="hljs-attr">"dependencies"</span><span class="hljs-punctuation">:</span> <span class="hljs-punctuation">{</span>
<span class="hljs-attr">"puppeteer"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"24.4.0"</span><span class="hljs-punctuation">,</span>
<span class="hljs-attr">"puppeteer-core"</span><span class="hljs-punctuation">:</span> <span class="hljs-string">"24.4.0"</span>
<span class="hljs-punctuation">}</span>
<span class="hljs-punctuation">}</span>
- 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:
<span class="hljs-keyword">RUN</span><span class="language-bash"> apt-get update && apt-get install -y \
chromium \
libnss3 \
libgconf-2-4 \
libxss1</span>
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:
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
<span class="hljs-attr">executablePath</span>: process.<span class="hljs-property">env</span>.<span class="hljs-property">PUPPETEER_EXECUTABLE_PATH</span> || puppeteer.<span class="hljs-title function_">executablePath</span>()
});
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:
<span class="hljs-comment">// Launch Puppeteer with a proxy server and authentication</span>
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({
<span class="hljs-attr">args</span>: [<span class="hljs-string">'--proxy-server=http://157.230.255.230:8118'</span>]
});
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">authenticate</span>({
<span class="hljs-attr">username</span>: <span class="hljs-string">'proxyUser'</span>,
<span class="hljs-attr">password</span>: <span class="hljs-string">'proxyPass'</span>
});
<span class="hljs-comment">// Optimize navigation with specific settings</span>
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">goto</span>(<span class="hljs-string">'https://example.com'</span>, {
<span class="hljs-attr">waitUntil</span>: <span class="hljs-string">'networkidle2'</span>,
<span class="hljs-attr">timeout</span>: <span class="hljs-number">30000</span>
});
Inclua tratamento de erros para garantir desempenho robusto na produção:
<span class="hljs-keyword">try</span> {
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">goto</span>(url);
} <span class="hljs-keyword">catch</span> (error) {
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">error</span>(<span class="hljs-string">'Proxy connection failed:'</span>, error.<span class="hljs-property">message</span>);
<span class="hljs-comment">// Add fallback logic or retry mechanism</span>
}
Para configurações corporativas, exporte as configurações de proxy no seu terminal:
<span class="hljs-built_in">export</span> HTTP_PROXY=<span class="hljs-string">"http://proxy.company.com:8080"</span>
<span class="hljs-built_in">export</span> HTTPS_PROXY=<span class="hljs-string">"https://proxy.company.com:8443"</span>
<span class="hljs-built_in">export</span> NO_PROXY=<span class="hljs-string">"localhost,127.0.0.1,.company.internal"</span>
Você também pode validar conexões proxy programaticamente:
<span class="hljs-keyword">const</span> <span class="hljs-title function_">validateProxy</span> = <span class="hljs-keyword">async</span> (<span class="hljs-params">page</span>) => {
<span class="hljs-keyword">try</span> {
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">goto</span>(<span class="hljs-string">'https://api.ipify.org?format=json'</span>);
<span class="hljs-keyword">const</span> content = <span class="hljs-keyword">await</span> page.<span class="hljs-title function_">content</span>();
<span class="hljs-keyword">return</span> content.<span class="hljs-title function_">includes</span>(<span class="hljs-string">'ip'</span>);
} <span class="hljs-keyword">catch</span> {
<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
};
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:
<span class="hljs-comment">// Validation script for environment setup</span>
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>();
<span class="hljs-keyword">const</span> page = <span class="hljs-keyword">await</span> browser.<span class="hljs-title function_">newPage</span>();
<span class="hljs-keyword">await</span> page.<span class="hljs-title function_">validateEnvironment</span>(); <span class="hljs-comment">// Custom validation</span>
<span class="hljs-keyword">await</span> browser.<span class="hljs-title function_">close</span>();
| 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:
<span class="hljs-keyword">const</span> browser = <span class="hljs-keyword">await</span> puppeteer.<span class="hljs-title function_">launch</span>({ <span class="hljs-attr">headless</span>: <span class="hljs-literal">true</span>, <span class="hljs-attr">args</span>: [<span class="hljs-string">'--disable-dev-shm-usage'</span>], <span class="hljs-attr">defaultViewport</span>: { <span class="hljs-attr">width</span>: <span class="hljs-number">1920</span>, <span class="hljs-attr">height</span>: <span class="hljs-number">1080</span> } });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. .
Artigos Relacionados
