Développer un programme de travail de métadonnées Asset Compute

Les programmes de travail personnalisés Asset Compute peuvent produire des données XMP (XML) qui sont renvoyées à AEM et stockées en tant que métadonnées sur une ressource.

Cas d’utilisation courants :

Ce que vous devez faire

Dans ce tutoriel, nous allons créer un programme de travail de métadonnées Asset Compute qui fournit les couleurs les plus couramment utilisées dans une ressource d’image et qui réécrit les noms des couleurs pour les renvoyer aux métadonnées de la ressource dans AEM. Bien que le programme de travail lui-même soit basique, ce tutoriel l’utilise pour explorer la manière dont les programmes de travail Asset Compute peuvent être utilisés pour écrire des métadonnées sur des ressources dans AEM as a Cloud Service.

Flux logique de l’appel d’un programme de travail de métadonnées Asset Compute

L’appel des programmes de travail de métadonnées d’Asset Compute est presque identique à celui des programmes de travail de génération de rendus binaires, la principale différence étant le type de retour, à savoir XMP (XML), dont les valeurs sont également écrites dans les métadonnées de la ressource.

Les programmes de travail Asset Compute implémentent l’API du programme de travail SDK Asset Compute, dans la fonction renditionCallback(...), qui est conceptuellement :

Configurer le fichier manifest.yml manifest

Tous les programmes de travail Assets Compute doivent être enregistrés dans manifest.yml.

Ouvrez le fichier manifest.yml et ajoutez une entrée de programme de travail qui configure le nouveau programme de travail, dans ce cas, metadata-colors.

Souvenez-vous que .yml est sensible aux espaces.

packages:
  __APP_PACKAGE__:
    license: Apache-2.0
    actions:
      worker:
        function: actions/worker/index.js
        web: 'yes'
        runtime: 'nodejs:12'
        limits:
          timeout: 60000 # in ms
          memorySize: 512 # in MB
          concurrency: 10
        annotations:
          require-adobe-auth: true
      metadata-colors:
        function: actions/metadata-colors/index.js
        web: 'yes'
        runtime: 'nodejs:12'
        limits:
          memorySize: 512 # in MB

function pointe vers l’implémentation du programme de travail créée dans l’étape suivante. Nommez les objets du programme de travail sémantiquement (par exemple, actions/worker/index.js aurait pu être nommé actions/rendition-circle/index.js, ce qui aurait été préférable), comme illustré dans l’URL du programme de travail et déterminez également le nom du dossier de la suite de tests du programme de travail.

Les éléments limits et require-adobe-auth sont configurés discrètement par programme de travail. Dans ce programme de travail, une mémoire de 512 MB est attribuée lorsque le code inspecte (potentiellement) des données d’image binaire volumineuses. Les limits restantes sont supprimées pour utiliser les valeurs par défaut.

Développer un programme de travail de métadonnées metadata-worker

Créez un fichier JavaScript de traitement des métadonnées dans le projet Asset Compute à l’emplacement manifest.yml défini pour le nouveau programme de travail, à l’emplacement /actions/metadata-colors/index.js.

Installer les modules npm

Installez les modules npm supplémentaires (@adobe/asset-compute-xmp, get-image-colors, et color-namer) qui sont utilisés dans ce programme de travail Assets Compute.

$ npm install @adobe/asset-compute-xmp
$ npm install get-image-colors
$ npm install color-namer

Code du programme de travail des métadonnées

Ce programme de travail ressemble beaucoup au programme de travail de génération des rendus, la principale différence réside dans le fait qu’il écrit des données XMP (XML) dans rendition.path pour qu’elles soient enregistrées et renvoyées à AEM.

"use strict";

const { worker, SourceCorruptError } = require("@adobe/asset-compute-sdk");
const fs = require("fs").promises;

// Require the @adobe/asset-compute-xmp module to create XMP
const { serializeXmp } = require("@adobe/asset-compute-xmp");

// Require supporting npm modules to derive image colors from image data
const getColors = require("get-image-colors");
// Require supporting npm modules to convert image colors to color names
const namer = require("color-namer");

exports.main = worker(async (source, rendition, params) => {
  // Perform any necessary source (input) checks
  const stats = await fs.stat(source.path);
  if (stats.size === 0) {
    // Throw appropriate errors whenever an erring condition is met
    throw new SourceCorruptError("source file is empty");
  }
  const MAX_COLORS = 10;
  const DEFAULT_COLORS_FAMILY = 'basic';

  // Read the color family parameter to use to derive the color names
  let colorsFamily = rendition.instructions.colorsFamily || DEFAULT_COLORS_FAMILY;

  if (['basic', 'hex', 'html', 'ntc', 'pantone', 'roygbiv'].indexOf(colorsFamily) === -1) {
      colorsFamily = DEFAULT_COLORS_FAMILY;
  }

  // Use the `get-image-colors` module to derive the most common colors from the image
  let colors = await getColors(source.path, { options: MAX_COLORS });

  // Convert the color Chroma objects to their closest names
  let colorNames = colors.map((color) => getColorName(colorsFamily, color));

  // Serialize the data to XMP metadata
  // These properties are written to the [dam:Asset]/jcr:content/metadata resource
  // This stores
  // - The list of color names is stored in a JCR property named `wknd:colors`
  // - The colors family used to derive the color names is stored in a JCR property named `wknd:colorsFamily`
  const xmp = serializeXmp({
      // Use a Set to de-duplicate color names
      "wknd:colors": [...new Set(colorNames)],
      "wknd:colorsFamily": colorsFamily
    }, {
      // Define any property namespaces used in the above property/value definition
      // These namespaces are automatically registered in AEM if they do not yet exist
      namespaces: {
        wknd: "https://wknd.site/assets/1.0/",
      },
    }
  );

  // Save the XMP metadata to be written back to the asset's metadata node
  await fs.writeFile(rendition.path, xmp, "utf-8");
});

/**
 * Helper function that derives the closest color name for the color, based on the colors family
 *
 * @param {*} colorsFamily the colors name family to use
 * @param {*} color the color to convert to a name
 */
function getColorName(colorsFamily, color) {
    if ('hex' === colorsFamily) {  return color; }

    let names = namer(color.rgb())[colorsFamily];

    if (names.length >= 1) { return names[0].name; }
}

Exécuter localement le programme de travail des métadonnées development-tool

Une fois le code du programme de travail terminé, il peut être exécuté à l’aide de l’outil de développement d’Asset Compute local.

Parce que notre projet d’Asset Compute contient deux programmes de travail (le rendu de cercle précédent et ce programme de travail de metadata-colors), la définition du profil de l’outil de développement Asset Compute répertorie les profils d’exécution pour les deux programmes de travail. La deuxième définition de profil pointe vers le nouveau programme de travail de metadata-colors.

Tester le programme de travail test

Les programmes de travail de métadonnées peuvent être testés à l’aide du même framework de test d’Asset Compute que les rendus binaires. La seule différence est que le fichier rendition.xxx dans le cas de test doit correspondre au rendu XMP (XML) attendu.

Déployer le programme de travail sur Adobe I/O Runtime deploy

Pour appeler ce nouveau programme de travail des métadonnées à partir d’AEM Assets, il doit être déployé dans Adobe I/O Runtime à l’aide de la commande :

$ aio app deploy

Notez que tous les programmes de travail seront déployés dans le projet. Consultez les instructions de déploiement complètes pour savoir comment déployer sur les espaces de travail d’évaluation et de production.

Intégrer aux profils de traitement AEM processing-profile

Appelez le programme de travail à partir d’AEM en créant ou en modifiant un service de profil de traitement personnalisé existant qui appelle ce programme de travail déployé.

Mettre à jour le schéma de métadonnées metadata-schema

Pour passer en revue les métadonnées des couleurs, mappez deux nouveaux champs du schéma de métadonnées de l’image avec les nouvelles propriétés de données de métadonnées renseignées par le programme de travail.

Traiter des ressources

Avec les métadonnées de couleur écrites dans les métadonnées de la ressource, sur la ressource [dam:Asset]/jcr:content/metadata, ces métadonnées sont indexées, ce qui augmente la capacité de découverte de ressources à l’aide de ces termes par le biais d’une recherche. Elles peuvent même être réécrites dans le fichier binaire de la ressource, si par la suite le workflow Écriture différée des métadonnées de gestion des ressources numériques est appelé dessus.

Rendu des métadonnées dans AEM Assets

Le fichier XMP généré par le programme de travail des métadonnées d’Asset Compute est également stocké en tant que rendu distinct sur la ressource. Ce fichier n’est généralement pas utilisé. En revanche, les valeurs appliquées au nœud de métadonnées de la ressource sont utilisées, mais la sortie XML brute du programme de travail est disponible dans AEM.

Code du programme de travail des couleurs de métadonnées sur Github

Le metadata-colors/index.js final est disponible sur Github à l’adresse :

La suite de tests du test/asset-compute/metadata-colors final est disponible sur Github à l’adresse :