Installation et configuration de Puppeteer : résolution des problèmes courants de dépendance et de Chromium

Table des matières

Installation et configuration de Puppeteer : résolution des problèmes courants de dépendance et de Chromium

Vous souhaitez automatiser Chrome ou Chromium en toute simplicité ? Marionnettiste est une Node.js Bibliothèque simplifiant l'automatisation du navigateur, idéale pour des tâches comme les tests et le scraping. Voici ce que vous apprendrez :

Intégration directe sur Latenode : Apprener comment Laténode améliore les flux de travail de scraping Web avec un intégration directe avec le navigateur sans tête basé sur Puppeteer et des fonctionnalités d'automatisation. Aucune préconfiguration nécessaire : ajoutez simplement le nœud et utilisez-le pour automatiser vos workflows !
Configuration requise:Utilisez Node.js 18+ et assurez-vous que votre système répond aux dépendances spécifiques au système d'exploitation.
Options d'installation:Installer Puppeteer avec npm i puppeteer (inclut Chrome pour les tests) ou npm i puppeteer-core (utilisez votre propre navigateur).
Des conseils de dépannage: Corrigez les erreurs de lancement de Chromium, les bibliothèques manquantes et les conflits de dépendances.
Configurations avancées:Optimisez les performances, configurez des proxys et gérez les variables d'environnement.

Avant de partager un guide complet sur les problèmes de configuration de Puppeteer, sachez que vous pouvez simplement l'ignorer et utiliser un nœud d'intégration direct et prêt à l'emploi sur Latenode ! Découvrez-le :

Ignorez la configuration de Puppeteer : utilisez notre intégration prête à l'emploi sur Laténode

Latenode s'intègre parfaitement à Puppeteer pour simplifier l'automatisation du navigateur. Nous allons explorer ci-dessous les fonctionnalités de Latenode et vous expliquer comment utiliser une intégration directe avec Puppeteer pour vos besoins d'automatisation.

Voici une description des principales fonctionnalités de Latenode :

Fonctionnalité	Description	Bénéfice
Navigateur sans tête	Intégration de la bibliothèque Puppeteer	Contrôle direct du navigateur
Assistant de code IA	Génération de code automatisée	Accélère le débogage et le codage
Flexibilité sans code	Plus de 300 intégrations sans code pour des ajustements de flux de travail personnalisés	Étend les fonctionnalités de Puppeteer
Prise en charge des packages NPM	Accès à plus d'un million de packages	Augmente les capacités d'automatisation

« Ce que j'ai le plus apprécié chez Latenode par rapport à la concurrence, c'est la possibilité d'écrire du code et de créer des nœuds personnalisés. » - Germaine H., Fondatrice d'Information Technology

Laténode Outils

Laténode

Latenode propose une intégration avec le nœud Headless Browser, qui est basé sur Puppeteer et vous permet d'ajouter du code directement dans l'éditeur et de l'utiliser pour des tâches telles que la récupération de toutes les informations disponibles sur un site Web, la prise de captures d'écran de pages, le remplissage de formulaires et généralement tout ce que Puppeteer prend en charge.

Pour trouver cette intégration, accédez simplement au dossier « Intégrations de code » de la bibliothèque de nœuds, où se trouve le nœud « Navigateur sans tête ». Ajoutez-le à votre script, cliquez dessus et un éditeur s'ouvrira pour vous permettre d'ajouter du code, quelle que soit sa complexité et sa longueur. Vous pouvez également spécifier l'adresse, l'identifiant et le mot de passe de votre proxy dans les paramètres.

Connexion d'un navigateur headless basé sur Puppeteer à d'autres intégrations

Mais un seul nœud ne suffit pas pour l'automatisation. Pour une personnalisation plus poussée, ajoutez un déclencheur et une autre action. Par exemple, un déclencheur et une réponse webhook pour surveiller les variations de taux de change à la Banque d'Angleterre, comme illustré dans le guide ci-dessus. Voici un exemple :

SCÉNARIO

Pourquoi choisir l'intégration Latenode plutôt qu'une solution basée sur VPS ?

« Latenode surpasse la concurrence avec une disponibilité de 99 %, une tarification abordable basée sur l'exécution et une interface conviviale. » – Hammad Hafeez

La tarification de Latenode est basée sur le temps d'exécution plutôt que sur les tâches individuelles, ce qui en fait une option économique pour l'automatisation Puppeteer à grande échelle. Cette plateforme permet aux développeurs de se concentrer sur la création de workflows performants sans se soucier des coûts excessifs.

Pour maximiser l'efficacité, vous pouvez utiliser les intégrations Javascript de Latenode, ainsi que 300 intégrations de bases de données, CRM, outils de gestion de projet et modèles d'IA comme Claude, ChatGPT et Gemini. Il existe de nombreux cas d'utilisation potentiels : sensibilisation automatisée, gestion de bases de données, web scraping, etc. En combinant Latenode et Puppeteer, vous pouvez centraliser et rationaliser vos processus d'automatisation.

Si vous souhaitez toujours un guide pour résoudre les problèmes de Puppeteer, consultez la description ci-dessous.

Échec du lancement de Chromium sur VPS ? Installer les dépendances manquantes sur Puppetter VPS.

Avant de commencer

Avant d'installer Puppeteer, assurez-vous que votre configuration répond aux dépendances nécessaires pour garantir une installation et un fonctionnement fluides.

Node.js installation

Node.js

Le marionnettiste a besoin Node.js à exécuter. Les dernières versions de Puppeteer fonctionnent avec Node.js version 18 ou supérieure, qui s'aligne sur la version LTS actuelle.

Pour vérifier votre version de Node.js, utilisez cette commande :

node --version

Si votre version est inférieure à 18, mettez à jour Node.js avant de continuer. Il est fortement recommandé d'utiliser la dernière version LTS. Après avoir confirmé votre version de Node.js, vérifiez la configuration système requise.

Configuration requise

La configuration requise pour Puppeteer dépend du système d'exploitation que vous utilisez. Voici un bref aperçu :

Système d'exploitation	Architecture	Composants requis	Taille approximative du téléchargement
Windows	x64	Chrome pour les tests	~280 Mo
macOS	x64, arm64	Chrome pour les tests	~170 Mo
Debian / Ubuntu	x64	Chrome pour les tests et les bibliothèques	~282 Mo

Lors de l'installation de Puppeteer, une version compatible de Chrome est automatiquement téléchargée pour les tests. La taille du téléchargement varie selon votre système d'exploitation (environ 280 Mo pour Windows, environ 170 Mo pour macOS et environ 282 Mo pour Debian/Ubuntu/Linux). .

Pour les utilisateurs de Linux, notamment Debian/Ubuntu, vous devrez installer des bibliothèques supplémentaires. Utilisez la commande suivante :

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

Voici quelques conseils supplémentaires pour des environnements spécifiques :

AWS EC2 Amazon Linux: Activez le référentiel EPEL et installez Chromium avant de configurer Puppeteer.
Environnements Docker: Ajoutez les bibliothèques partagées requises et le package Chromium à votre Dockerfile.
Manuscrit Projets: Utilisation TypeScript version 4.7.4 ou supérieure pour accéder aux dernières définitions de type de Puppeteer et améliorer la prise en charge de l'IDE.

Étapes d'installation de base

Une fois que vous avez confirmé votre configuration Node.js et la configuration système requise, vous pouvez installer Puppeteer à l'aide de npm.

Guide d'installation de npm

Vous avez deux façons d'installer Puppeteer via npm :

Installation standard: Cette option télécharge automatiquement Chrome pour les tests :
```
npm i puppeteer
```
Installation du noyau:Utilisez ceci si vous souhaitez gérer les navigateurs séparément et ignorer le téléchargement de Chrome pour les tests :
```
npm i puppeteer-core
```

Avec l'installation standard, Chrome pour les tests et le chrome-headless-shell les binaires sont téléchargés sur $HOME/.cache/puppeteerConsultez la section Configuration requise pour plus de détails sur les tailles de téléchargement.

Une fois installé, vous êtes prêt à tester votre configuration.

Test de votre configuration

Commencez par créer un fichier nommé test.js et ajoutez le script suivant :

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();
})();

Exécutez le script avec :

node test.js

Si le script s'exécute correctement et affiche le titre de la page, votre installation fonctionne correctement.

Des conseils de dépannage

Utilisateurs de Linux:Utilisez votre gestionnaire de paquets pour vous assurer que toutes les dépendances requises sont installées.
Utilisateurs Windows: Vérifiez que les autorisations du sandbox de Chrome sont correctement configurées.
Si Chrome n'est pas trouvé à son emplacement par défaut, définissez le PUPPETEER_CACHE_DIR variable d'environnement pour pointer vers le répertoire d'installation correct.

« Courir sans bac à sable, c'est fortement découragé. Envisagez plutôt de configurer un bac à sable. »

Pour une meilleure stabilité et un entretien plus facile, vous pouvez créer un .puppeteerrc.cjs fichier pour configurer le comportement de Puppeteer au lieu de passer des arguments directement au launch méthode.

Résolution des problèmes de chrome

Les problèmes de Chromium proviennent souvent de bibliothèques manquantes ou de paramètres incorrects.

Utilisation de Chromium local

Si vous préférez utiliser une installation Chromium existante plutôt que d'en télécharger une nouvelle, Puppeteer peut être configuré pour fonctionner avec votre navigateur local. Cette méthode est utile si vous avez besoin d'une version spécifique de Chromium ou si vous gérez manuellement les installations de navigateur.

Pour lier Puppeteer à votre Chromium local, ajustez vos paramètres de lancement comme ceci :

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

Assurez-vous que toutes les bibliothèques nécessaires sont installées. Sous Linux, vous pouvez identifier les bibliothèques manquantes avec :

ldd chrome | grep not

Si l’utilisation d’une installation locale n’est pas une option, envisagez d’installer Chromium séparément en suivant les étapes ci-dessous.

Installation de Chromium séparément

À partir de Puppeteer v20.0.0, Chrome pour les tests est téléchargé à la place de Chromium.

Présentation de la compatibilité :

Version Marionnettiste	Version du navigateur	Taille du téléchargement
v24.4.0	Chrome pour les tests 134.0.6998.35	~170 Mo (macOS)
v24.3.1	Chrome pour les tests 133.0.6943.141	~282 Mo (Linux)
v24.3.0	Chrome pour les tests 133.0.6943.126	~280 Mo (Windows)

Si vous rencontrez une erreur « Échec du lancement de Chrome », essayez ces correctifs :

Vérifier les dépendances:Installez toutes les bibliothèques manquantes sur les systèmes basés sur Debian :
```
sudo apt-get install -y libasound2 libatk1.0-0 libgbm-dev
```
Ajuster les paramètres de mémoire: Pour les environnements Docker, augmentez /dev/shm taille ou utiliser le --disable-dev-shm-usage drapeau:
```
const browser = await puppeteer.launch({
  args: ['--disable-dev-shm-usage']
});
```
Définir les délais d'expiration de la navigation: Évitez les blocages en définissant un délai d'expiration de navigation personnalisé, par exemple 60 secondes :
```
await page.setDefaultNavigationTimeout(60000); // 60 seconds
```

Chrome(-ium) sans tête nécessite de nombreuses dépendances, et Puppeteer ne les installe pas toutes. - savebreach.com

Pour les environnements tels que GitLab CI ou les cas où le sandboxing est désactivé (non recommandé), incluez des arguments de lancement spécifiques :

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

Pour contourner les avertissements liés à HTTPS dans les versions récentes de Chrome, désactivez la fonctionnalité HttpsFirstBalancedModeAutoEnable :

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

Gestion des dépendances

Une gestion efficace des dépendances est essentielle pour éviter les échecs de lancement et les comportements imprévisibles. Cette section traite de la résolution des conflits de versions et de la mise à jour des packages pour éviter les erreurs d'exécution.

Correction des conflits de paquets

Les conflits de paquets entraînent souvent des erreurs telles que « Impossible de trouver le module 'puppeteer-core/internal/...' » ou des problèmes de lancement de Chrome. Voici comment résoudre ces problèmes :

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

Étapes de dépannage :

Vérifier la version de Node.js: Assurez-vous d'utiliser Node.js 18 ou une version ultérieure. Les versions plus anciennes peuvent entraîner des problèmes de compatibilité.
Vérifier les bibliothèques systèmeSous Linux, assurez-vous que toutes les bibliothèques système requises sont installées. Consultez la liste des dépendances dans la section Configuration requise.
Consultez les politiques de Chrome: Les politiques de Chrome peuvent entrer en conflit avec les valeurs par défaut de Puppeteer --disable-extensions drapeau. Essayez de lancer sans lui :

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

Une fois les conflits résolus, mettez à jour vos packages pour garantir une stabilité continue.

Maintenir les packages à jour

La mise à jour régulière des dépendances réduit les risques de sécurité et garantit la compatibilité. Voici comment gérer ce processus :

Suivre les dépendances

Utilisez un tableau simple pour surveiller les versions des packages, les dates de mise à jour et leur importance :

Forfait	Version actuelle	Dernière mise à jour	Requis par
marionnettiste	24.4.0	Mar 2024	Fonctionnalité de base
ws	8.17.1	Fév 2024	Prise en charge de WebSocket
déboguer	4.3.4	Jan 2024	Système de journalisation

Gestion des versions

Lors de la mise à jour, utilisez avec prudence les plages de versions sémantiques. Pour les dépendances critiques, épinglez les versions exactes afin d'éviter les modifications inattendues :

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

Dépannage des mises à jour

Générer un rapport de dépendance détaillé avec :

npm list --all > dependency-report.txt

Ce rapport permet d’identifier les conflits et les dépendances imbriquées problématiques.

Pour les environnements tels que Docker ou GitLab CI, assurez-vous que votre configuration inclut les packages système nécessaires :

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

Paramètres supplémentaires

Ajustez Puppeteer pour des configurations avancées avec ces configurations supplémentaires.

Variables d'environnement

Les variables d'environnement vous permettent d'ajuster le comportement de Puppeteer et de remplacer les paramètres par défaut.

Voici quelques variables clés :

Variable	Objectif	Exemple de valeur
PUPPETEER_CACHE_DIR	Spécifie un répertoire de cache personnalisé pour les téléchargements du navigateur	/usr/local/cache/marionnettiste
CHEMIN_EXECUTABLE_DU_MARIONNETTE	Pointe vers un exécutable de navigateur spécifique	/usr/bin/chrome
HTTP PROXY	Configure les paramètres du proxy HTTP	http://proxy.company.com:8080
HTTPS_PROXY	Configure les paramètres du proxy HTTPS	https://proxy.company.com:8443
NO_PROXY	Liste les domaines exclus de l'utilisation du proxy	localhost,127.0.0.1

Pour les installations Chromium personnalisées, définissez le chemin exécutable comme ceci :

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

Une fois les variables d’environnement définies, vous pouvez configurer des proxys pour gérer efficacement les restrictions réseau.

Configuration du proxy

Pour utiliser un serveur proxy avec Puppeteer, appliquez la configuration suivante :

// 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
});

Inclure la gestion des erreurs pour garantir des performances robustes en production :

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

Pour les configurations d'entreprise, exportez les paramètres proxy dans votre 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"

Vous pouvez également valider les connexions proxy par programmation :

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;
  }
};

Cela garantit que votre configuration proxy fonctionne correctement avant de continuer.

Prochaines étapes

Liste de contrôle de la configuration

Avant de commencer l'automatisation avec Puppeteer, assurez-vous que votre environnement est correctement configuré. Utilisez le script ci-dessous pour valider votre configuration :

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

Composant de configuration	Étape de vérification	Problème courant
Node.js	Vérifier la compatibilité des versions	Version obsolète de Node.js
Package.json	Vérifier l'entrée « type » : « module »	Erreurs d'importation ES6
Installation de Chrome	Tester le lancement du navigateur	Binaire Chromium manquant
Paramètres de mémoire	Vérifier la taille de /dev/shm dans Docker	Crash du navigateur au lancement
Gestion des ressources	Implémenter browser.close()	Fuites de mémoire

Une fois votre configuration vérifiée, vous pouvez vous concentrer sur l’amélioration de vos flux de travail pour de meilleurs résultats d’automatisation.

Conseils de mise en route

CarriyoLe système PDF de gérait efficacement 10,000 95 étiquettes d'expédition par jour, atteignant une latence p365 de XNUMX ms Pour atteindre des niveaux de performance similaires, envisagez ces stratégies :

Gestion des ressourcesDésactivez les fonctionnalités inutiles pour économiser des ressources. Par exemple, lancez Puppeteer avec des paramètres optimisés :
```
const browser = await puppeteer.launch({
  headless: true,
  args: ['--disable-dev-shm-usage'],
  defaultViewport: { width: 1920, height: 1080 }
});
```
Gestion des erreurs :Utilisez des méthodes de récupération d’erreur robustes, telles que des blocs try-catch et des gestionnaires d’erreurs personnalisés adaptés à des problèmes spécifiques.
Optimisation des performances:Augmentez la vitesse en :
- Mise en cache des données fréquemment utilisées
- Interception des requêtes réseau
- Exécution de tâches en parallèle
- Utilisation de Chrome DevTools pour surveiller les performances

Pour une automatisation plus poussée, explorez la plateforme de workflow low-code de Latenode. Elle propose une tarification basée sur l'exécution et une gamme de fonctionnalités pour simplifier les implémentations complexes de Puppeteer. .