Installer et configurer Puppeteer : résoudre les problèmes courants de dépendances et de Chromium

Vous souhaitez automatiser Chrome ou Chromium en toute simplicité ? Puppeteer est une bibliothèque Node.js qui simplifie l’automatisation des navigateurs, idéale pour des tâches comme les tests et le scraping. Voici ce que vous allez découvrir :

• Intégration directe sur Latenode : Découvrez comment Latenode améliore les workflows de scraping web grâce à une intégration directe avec le navigateur headless basé sur Puppeteer et à des fonctionnalités pensées pour l’automatisation. Vous n’avez rien à préconfigurer : ajoutez simplement le nœud et utilisez-le dans votre automatisation de workflow !
• Prérequis de configuration : utilisez Node.js 18+ et assurez-vous que votre système répond aux dépendances propres à votre système d’exploitation.
• Options d’installation : installez Puppeteer avec npm i puppeteer (inclut Chrome for Testing) ou npm i puppeteer-core (utilisez votre propre navigateur).
• 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 vous présenter un guide complet sur les problèmes de configuration de Puppeteer, sachez que vous pouvez tout simplement l’éviter et utiliser un nœud d’intégration direct et prêt à l’emploi sur Latenode ! Découvrez-le :

Évitez de configurer Puppeteer : utilisez notre intégration prête à l’emploi sur Latenode

Latenode fonctionne parfaitement avec Puppeteer pour simplifier l’automatisation des navigateurs. Ci-dessous, nous explorons les fonctionnalités de Latenode et la manière d’utiliser une intégration directe avec Puppeteer pour vos besoins d’automatisation.

Voici un aperçu des principales fonctionnalités de Latenode :

« 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 dans l’informatique [3]

Outils Latenode

Latenode propose une intégration avec le nœud Navigateur headless, basé sur Puppeteer, qui vous permet d’ajouter directement du code dans l’éditeur et de l’utiliser pour des tâches telles que le scraping de toutes les informations disponibles sur un site web, la capture d’écran de pages, le remplissage de formulaires et, plus généralement, tout ce que Puppeteer prend en charge.

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

Connecter le navigateur headless basé sur Puppeteer à d’autres intégrations

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

WORKFLOW

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

« Latenode surpasse largement la concurrence grâce à une disponibilité de 99 %, à une tarification abordable basée sur l’exécution et à une interface conviviale. » - Hammad Hafeez [3]

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 solution économique pour l’automatisation Puppeteer à grande échelle. Cette plateforme permet aux développeurs de se concentrer sur la création de workflows robustes sans se soucier de coûts excessifs.

Pour maximiser l’efficacité, vous pouvez utiliser l’intégration JavaScript de Latenode, ainsi que plus de 300 intégrations avec des bases de données, des CRM, des outils de gestion de projet et des modèles d’IA tels que Claude, ChatGPT et Gemini. Les cas d’usage potentiels sont nombreux : prospection automatisée, gestion de bases de données, scraping web, etc. En combinant Latenode et Puppeteer, vous pouvez centraliser et rationaliser vos processus d’automatisation.

sbb-itb-23997f1

Si vous souhaitez tout de même un guide pour résoudre les problèmes liés à Puppeteer, consultez l’analyse ci-dessous.

Échec du lancement de Chromium sur un VPS ? Installez les dépendances manquantes pour Puppeteer sur votre VPS

Avant de commencer

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

Configuration de Node.js

Puppeteer nécessite Node.js pour fonctionner. Les dernières versions de Puppeteer sont compatibles avec Node.js version 18 ou ultérieure, ce qui correspond à 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 Node.js à jour avant de continuer. L’utilisation de la dernière version LTS est fortement recommandée. Après avoir confirmé votre version de Node.js, vérifiez les exigences liées au système d’exploitation de votre système.

Configuration système requise

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

Lors de l’installation de Puppeteer, une version compatible de Chrome for Testing sera automatiquement téléchargée. La taille du téléchargement varie selon votre système d’exploitation (~280MB pour Windows, ~170MB pour macOS et ~282MB pour Debian/Ubuntu Linux) [1].

Pour les utilisateurs Linux, en particulier sous 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 dépôt EPEL et installez Chromium avant de configurer Puppeteer.
• Environnements Docker : ajoutez les bibliothèques partagées requises et le package Chromium à votre Dockerfile.
• Projets TypeScript : utilisez TypeScript version 4.7.4 ou ultérieure pour accéder aux dernières définitions de types de Puppeteer et améliorer la prise en charge par votre IDE.

Étapes d’installation de base

Une fois votre configuration Node.js et les exigences système confirmées, vous pouvez installer Puppeteer avec npm.

Guide d’installation npm

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

• Installation standard : cette option télécharge automatiquement Chrome for Testing :

  npm i puppeteer
  

• Installation Core : utilisez cette option si vous souhaitez gérer les navigateurs séparément et éviter de télécharger Chrome for Testing :

  npm i puppeteer-core
  

Avec l’installation standard, Chrome for Testing et le binaire chrome-headless-shell sont téléchargés dans $HOME/.cache/puppeteer. Consultez la section Configuration système requise pour connaître les tailles de téléchargement.

Une fois l’installation terminée, vous êtes prêt à tester votre configuration.

Tester 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.

Conseils de dépannage

• Utilisateurs Linux : utilisez votre gestionnaire de packages 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 est introuvable dans son emplacement par défaut, définissez la variable d’environnement PUPPETEER_CACHE_DIR pour qu’elle pointe vers le bon répertoire d’installation.

« L’exécution sans sandbox est fortement déconseillée. Envisagez plutôt de configurer un sandbox. » [2]

Pour une meilleure stabilité et une maintenance simplifiée, vous pouvez créer un fichier .puppeteerrc.cjs afin de configurer le comportement de Puppeteer au lieu de passer directement des arguments à la méthode launch.

Résoudre les problèmes liés à Chromium

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

Utiliser 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 précise de Chromium ou si vous gérez manuellement les installations de navigateurs.

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

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 possible, envisagez d’installer Chromium séparément à l’aide des étapes ci-dessous.

Installer Chromium séparément

À partir de Puppeteer v20.0.0, Chrome for Testing est téléchargé à la place de Chromium.

Aperçu de compatibilité :

Si vous rencontrez une erreur « Failed to launch chrome », essayez ces correctifs :

1. Vérifier les dépendances : installez les bibliothèques manquantes sur les systèmes basés sur Debian :

   sudo apt-get install -y libasound2 libatk1.0-0 libgbm-dev
   

2. Ajuster les paramètres de mémoire : pour les environnements Docker, augmentez la taille de /dev/shm ou utilisez l’indicateur --disable-dev-shm-usage :

   const browser = await puppeteer.launch({
     args: ['--disable-dev-shm-usage']
   });
   

3. Définir les délais de navigation : évitez les blocages en définissant un délai de navigation personnalisé, par exemple 60 secondes :

   await page.setDefaultNavigationTimeout(60000); // 60 seconds
   

« Headless chrome(-ium) a besoin de nombreuses dépendances pour fonctionner, 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é (ce qui n’est pas 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']
});

Gérer les dépendances

Gérer efficacement les dépendances est essentiel pour éviter les échecs de lancement et les comportements imprévisibles. Cette section explique comment résoudre les conflits de versions et maintenir les packages à jour afin d’éviter les erreurs d’exécution.

Résoudre les conflits de packages

Les conflits de packages entraînent souvent des erreurs telles que « Cannot find 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 provoquer des problèmes de compatibilité.
• Vérifier les bibliothèques système : sous Linux, assurez-vous que toutes les bibliothèques système requises sont installées. Consultez la liste des dépendances dans la section Configuration système requise.
• Examiner les politiques Chrome : les politiques Chrome peuvent entrer en conflit avec l’indicateur --disable-extensions par défaut de Puppeteer. Essayez de lancer Puppeteer sans cet indicateur :

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

Une fois les conflits résolus, mettez vos packages à jour afin de garantir une stabilité durable.

Maintenir les packages à jour

Mettre régulièrement les dépendances à jour 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 suivre les versions des packages, leurs dates de mise à jour et leur importance :

• Gestion des versions

Lors des mises à jour, utilisez avec précaution les plages de versionnage sémantique. Pour les dépendances critiques, épinglez des versions exactes afin d’éviter des changements inattendus :

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

• Dépanner les mises à jour

Générez un rapport détaillé sur les dépendances 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 comme 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 les configurations avancées grâce à ces paramètres additionnels.

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 :

Pour les installations Chromium personnalisées, définissez le chemin de l’exécutable comme suit :

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 afin de 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
});

Incluez une gestion des erreurs pour assurer 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 de 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 poursuivre.

Prochaines étapes

Liste de contrôle de 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();

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

Conseils pour démarrer

Le système PDF de Carriyo a traité efficacement 10 000 étiquettes d’expédition par jour, avec une latence p95 de 365 ms [4]. Pour atteindre des niveaux de performance similaires, envisagez les stratégies suivantes :

• Gestion des ressources : désactivez les fonctionnalités inutiles afin d’économiser les 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 robustes de récupération après erreur, telles que des blocs try-catch et des gestionnaires d’erreurs personnalisés adaptés à des problèmes spécifiques.

• Optimisation des performances : améliorez la vitesse en :

  • Mettant en cache les données fréquemment utilisées
  • Interceptant les requêtes réseau
  • Exécutant les tâches en parallèle
  • Utilisant Chrome DevTools pour surveiller les performances

Pour une automatisation plus avancée, explorez la plateforme de workflows 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 Puppeteer complexes [3].