Exécutez puppeteer-core sur Heroku (édition Docker)

Il existe quelques exemples qui utilisent puppeteer-heroku-buildpack, mais il n'y a pas beaucoup d'exemples qui utilisent Docker, alors prenez note.

Exécutez un conteneur Docker sur Heroku

Presque tout fonctionne avec un serveur HTTP qui n'exécute qu'un seul conteneur. Tout ce que vous avez à faire est de démarrer le serveur HTTP avec le numéro de port spécifié par $ PORT.

• https://devcenter.heroku.com/articles/container-registry-and-runtime#dockerfile-commands-and-runtime
• https://devcenter.heroku.com/articles/build-docker-images-heroku-yml

Les détails sont écrits.

Tout d'abord, essayez de déployer quelque chose qui utilise simplement le serveur http.server de Python.

Dockerfile

FROM python:3.8-alpine

heroku.yml

build:
  docker:
    web: Dockerfile
run:
  web: python -m http.server $PORT

Paramètres d'application requis uniquement la première fois

$ heroku create
$ heroku stack:set container

Déployer

Juste git push. C'est vraiment simple.

$ git push heroku master

Créez et déployez une image Docker avec puppeteer-core et Google Chrome

marionnettiste a la possibilité de télécharger Chromium, mais il est préférable d'utiliser quand même Google Chrome (Stable). (préjudice)

Alors, essayez de déployer marionnettiste-core, qui ne dispose pas de la fonction de téléchargement Chromium, et Google Chrome dans une seule image Docker.

Dockerfile

# ref: https://github.com/puppeteer/puppeteer/blob/main/.ci/node12/Dockerfile.linux
FROM node:12-slim

# Install latest chrome dev package and fonts to support major charsets (Chinese, Japanese, Arabic, Hebrew, Thai and a few others)
# Note: this installs the necessary libs to make the bundled version of Chromium that Puppeteer
# installs, work.
RUN apt-get update \
    && apt-get install -y wget gnupg \
    && wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
    && sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list' \
    && apt-get update \
    && apt-get install -y google-chrome-stable fonts-ipafont-gothic fonts-wqy-zenhei fonts-thai-tlwg fonts-kacst fonts-freefont-ttf libxss1 \
    --no-install-recommends \
    && rm -rf /var/lib/apt/lists/*

ENV PUPPETEER_EXECUTABLE_PATH /usr/bin/google-chrome-stable
ENV PUPPETEER_PRODUCT chrome

RUN mkdir /app
WORKDIR /app
COPY package.json /app/package.json
RUN npm install
COPY index.js /app/index.js
CMD npm start

Pour index.js, créez simplement un serveur HTTP de manière appropriée, recherchez hogehoge sur Google lorsque des paramètres tels que ? Q = hogehoge sont spécifiés et affichez le texte de l'écran des résultats de la recherche. Avec des choses.

index.js

const http = require("http");
const url = require("url");
const puppeteer = require("puppeteer-core");

//create a server object:
http
  .createServer((req, res) => {
    const requestUrl = url.parse(req.url, true);
    let keyword = requestUrl.query["q"];
    if (!keyword) {
      res.write("request with ?q=xxxx");
      res.end();
    } else {
      puppeteer
        .launch({
          args: ["--no-sandbox", "--disable-setuid-sandbox"],
          executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,
        })
        .then(async (browser) => {
          const page = (await browser.pages())[0] || (await browser.newPage());

          //Fonctionnement automatique à partir d'ici
          await page.goto("https://google.com/");
          await page.type("input[name='q']", requestUrl.query["q"]);
          await Promise.all([
            page.waitForNavigation(),
            page.keyboard.press("Enter"),
          ]);

          let text = await page.evaluate(() => document.body.textContent);
          await page.close();

          res.write(text);
          res.end();
        });
    }
  })
  .listen(process.env.PORT);

package.json est exactement comme npm init --yes`` npm install puppeteer-core sans aucune torsion particulière.

package.json

{
  "name": "heroku-docker-playground",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/YusukeIwaki/heroku-docker-playground.git"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "bugs": {
    "url": "https://github.com/YusukeIwaki/heroku-docker-playground/issues"
  },
  "homepage": "https://github.com/YusukeIwaki/heroku-docker-playground#readme",
  "dependencies": {
    "puppeteer-core": "^5.2.1"
  }
}

heroku.yml

build:
  docker:
    web: Dockerfile
run:
  web: npm start

Cela prend beaucoup de temps car la construction de docker est effectuée au moment du déploiement, mais si vous attendez, le serveur HTTP démarrera naturellement.

Avec ce genre de sentiment, si le texte du résultat du cas Google apparaît dans une rangée, il est possible de communiquer.

Peut-être que le dramaturge travaillera aussi

Si marionnettiste-core fonctionne, le dramaturge-core fonctionnera également.

Pour les dramaturges, le Dockerfile est publié par Microsoft, vous pouvez donc vous y référer. https://github.com/microsoft/playwright/blob/master/docs/docker/Dockerfile.bionic

C'est un aparté complet, mais comme le dramaturge n'est pas intuitif à utiliser avec Azure Functions à ce stade, Heroku est fortement recommandé pour les personnes qui souhaitent simplement faire fonctionner le dramaturge en réponse à une requête HTTP!