Gérer et déployer rapidement des applications à l'aide de couches publiques - Function Compute

Les couches publiques officielles de Function Compute (FC) fournissent des environnements d'exécution préconfigurés et des dépendances courantes pour les langages de programmation populaires. Attachez une couche à votre fonction au lieu d'inclure les dépendances dans votre package de code. Contrairement aux couches personnalisées, les couches publiques officielles ne nécessitent aucune configuration d'environnement : les environnements d'exécution et les bibliothèques sont préinstallés.

Pourquoi utiliser les couches publiques officielles :

Packages de déploiement plus légers. Gardez les dépendances hors de votre archive de code.
Aucune configuration d'environnement requise. Les environnements d'exécution standard et les bibliothèques sont préinstallés.
Réutilisation entre les fonctions. Attachez la même couche à n'importe quelle fonction de votre compte.
Mises à jour indépendantes. Mettez à jour le code de la fonction sans toucher à ses dépendances.

Pour connaître les dernières versions des couches et les instructions d'utilisation, consultez awesome-layers.

Exemple 1 : Capturer des captures d'écran de pages web avec Node.js 16 et Puppeteer

Puppeteer automatise les tâches du navigateur via Chrome ou Chromium : capture d'écrans, génération de PDF, soumission de formulaires, exécution de tests d'interface utilisateur et simulation de saisie clavier. Il s'exécute en tant que navigateur headless sur Node.js.

Cet exemple crée une fonction qui prend une capture d'écran complète de n'importe quelle URL et renvoie l'image au format PNG.

Steps overview: Créez une fonction événementielle → Ajoutez le code de la fonction → Attachez la couche publique Puppeteer → Testez la fonction.

Étape 1 : Créer une fonction événementielle

Sur la page Create Function, définissez les paramètres suivants et conservez les valeurs par défaut pour le reste. Pour plus de détails, consultez Créer une fonction événementielle.

Paramètre	Valeur
Type de fonction	Event Function
Environnement d'exécution	Node.js 16
Capacité mémoire	1024 Mo

Étape 2 : Ajouter le code de la fonction

Sur la page des détails de la fonction, cliquez sur l'onglet Code, remplacez le contenu de index.js par le code suivant, puis cliquez sur Deploy.

const fs = require('fs');
const puppeteer = require('puppeteer');

function autoScroll(page) {
  return page.evaluate(() => {
      return new Promise((resolve, reject) => {
          var totalHeight = 0;
          var distance = 100;
          var timer = setInterval(() => {
              var scrollHeight = document.body.scrollHeight;
              window.scrollBy(0, distance);
              totalHeight += distance;
              if (totalHeight >= scrollHeight) {
                  clearInterval(timer);
                  resolve();
              }
          }, 100);
      })
  });
}

exports.handler = async (event, context, callback) => {
  console.log('Node version is: ' + process.version);

  try {
    const browser = await puppeteer.launch({
        headless: true,
        args: [
            '--disable-gpu',
            '--disable-dev-shm-usage',
            '--disable-setuid-sandbox',
            '--no-first-run',
            '--no-zygote',
            '--no-sandbox'
        ]
    });

    // 1. Read the target URL from the query string; fall back to the Serverless Devs homepage
    let url = 'https://www.serverless-devs.com';
    if (event.queryStringParameters && event.queryStringParameters.url) {
        url = event.queryStringParameters.url;
    }
    if (!url.startsWith('https://') && !url.startsWith('http://')) {
        url = 'http://' + url;
    }

    const page = await browser.newPage();
    await page.emulateTimezone('Asia/Shanghai');
    await page.goto(url, { waitUntil: 'networkidle2' });
    await page.setViewport({ width: 1200, height: 800 });

    // 2. Scroll the full page before taking the screenshot
    await autoScroll(page);

    // 3. Save a full-page PNG screenshot to /tmp/example
    let path = '/tmp/example';
    let contentType = 'image/png';
    await page.screenshot({ path: path, fullPage: true, type: 'png' });

    await browser.close();

    const screenshot = fs.readFileSync(path);

    // 4. Return the screenshot as a base64-encoded HTTP response body
    const response = {
        statusCode: 200,
        headers: {
            'Content-Type': contentType
        },
        body: screenshot.toString('base64'),
        isBase64Encoded: true
    };

    callback(null, response);
  } catch (err) {
    const errorResponse = {
        statusCode: 500,
        headers: {
            'Content-Type': 'text/plain'
        },
        body: err.message
    };
    callback(null, errorResponse);
  }
};

Étape 3 : Attacher la couche publique Puppeteer

Attachez la couche publique officielle Puppeteer17x à votre fonction. Pour des instructions détaillées, consultez Configurer des couches communes dans la console Function Compute.

Étape 4 : Tester la fonction

Créez un déclencheur HTTP. Dans la colonne Configurations du déclencheur, copiez l'URL Internet Endpoint et collez-la dans un navigateur. Pour obtenir des instructions, consultez Créer un déclencheur.

Une capture d'écran PNG complète du site web Serverless Devs est capturée et automatiquement téléchargée sur votre machine locale.

Exemple 2 : Exécuter un environnement d'exécution personnalisé .NET 6 avec des couches publiques

Cet exemple montre comment utiliser une couche publique officielle pour exécuter une fonction web .NET 6 sans inclure l'environnement d'exécution .NET dans votre package de code.

Steps overview: Créez une fonction web → Testez la fonction.

Étape 1 : Créer une fonction web

Sur la page Create Function, configurez les paramètres comme indiqué ci-dessous et conservez les valeurs par défaut pour le reste. Pour plus de détails, consultez Créer une fonction web.

Une fois la fonction créée, ouvrez l'exemple de fichier Program.cs dans WebIDE :

program.cs

L'exemple de code définit quatre comportements clés :

① Le serveur écoute sur 0.0.0.0:9000. Les services d'environnement d'exécution personnalisé doivent écouter sur 0.0.0.0:CAPort ou *:CAPort — et non sur 127.0.0.1 ou localhost. Pour plus de détails, consultez Principes.
② La route / renvoie la chaîne "Hello World! ".
③ La route /invoke gère les invocations de fonction. Pour plus de détails, consultez Fonctions web.
④ La route /initialize correspond au hook de cycle de vie Initializer, qui s'exécute une fois lors du démarrage de l'instance. Pour plus de détails, consultez Hooks de cycle de vie pour les instances de fonction.

Étape 2 : Tester la fonction

Tester la route racine

Dans la colonne Configurations du déclencheur, copiez l'URL Internet Endpoint et collez-la directement dans un navigateur (sans suffixe de chemin). La réponse est automatiquement téléchargée sur votre machine locale.

Tester les routes invoke et initialize

Ajoutez /invoke ou /initialize au point de terminaison public et envoyez une requête POST :

curl -XPOST <public-endpoint>/invoke
curl -XPOST <public-endpoint>/initialize

La figure suivante montre le résultat de l'exécution.