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

Les layers publics officiels de Function Compute (FC) fournissent des environnements d'exécution préconfigurés ainsi que des dépendances courantes pour les langages de programmation populaires. Associez un layer à votre fonction plutôt que d'inclure les dépendances dans votre package de code. Contrairement aux layers personnalisés, les layers publics officiels ne nécessitent aucune configuration d'environnement : les environnements d'exécution et les bibliothèques sont déjà installés.

Avantages des layers publics officiels :

Packages de déploiement allégés. Excluez les dépendances de votre archive de code.
Aucune configuration d'environnement requise. Les environnements d'exécution et bibliothèques standards sont préinstallés.
Réutilisation entre fonctions. Associez un même layer à n'importe quelle fonction de votre compte.
Mises à jour indépendantes. Mettez à jour le code de la fonction sans modifier ses dépendances.

Pour consulter les dernières versions des layers et leurs instructions d'utilisation, reportez-vous à awesome-layers.

Exemple 1 : Capturer des pages web avec Node.js 16 et Puppeteer

Puppeteer automatise les tâches navigateur via Chrome ou Chromium : capture d'écrans, génération de PDF, envoi de formulaires, exécution de tests d'interface utilisateur et simulation de saisies clavier. Il fonctionne comme un navigateur headless sur Node.js.

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

Steps overview: Créer une fonction événementielle → Ajouter le code de la fonction → Associer le layer public Puppeteer → Tester 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 tous les autres champs. 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 MB

Étape 2 : Ajouter le code de la fonction

Sur la page de détails de la fonction, cliquez sur l'onglet Code, remplacez le contenu du fichier 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 : Associer le layer public Puppeteer

Associez le layer public officiel Puppeteer17x à votre fonction. Pour obtenir des instructions détaillées, consultez Configurer des layers courants 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 du Public Endpoint et collez-la dans un navigateur. Pour plus d'informations, consultez Créer un déclencheur.

Une capture d'écran complète au format PNG du site web Serverless Devs est généré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 layers publics

Cet exemple illustre l'utilisation d'un layer public officiel pour exécuter une fonction web .NET 6 sans inclure l'environnement d'exécution .NET dans votre package de code.

Steps overview: Créer une fonction web → Tester 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 tous les autres champs. Pour plus de détails, consultez Créer une fonction web.

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

program.cs

Le code d'exemple définit quatre comportements essentiels :

① 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 ni 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 seule fois lors du démarrage de l'instance. Pour plus de détails, consultez Hooks de cycle de vie des instances de fonction.

Étape 2 : Tester la fonction

Tester la route racine

Dans la colonne Configurations du déclencheur, copiez l'URL du Public 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 à l'endpoint public et envoyez une requête POST :

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

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