Utveckla en metadataarbetare från Asset Compute

Anpassade Asset Compute-arbetare kan producera XMP-data (XML) som skickas tillbaka till AEM och lagras som metadata för en resurs.

Exempel på vanliga användningsområden:

Vad du ska göra

I den här självstudiekursen skapar vi en metadataarbetare från Asset Compute som hämtar de vanligaste färgerna i en bildresurs och skriver tillbaka namnen på färgerna till resursens metadata i AEM. Även om arbetaren själv är grundläggande används den här självstudien för att utforska hur Asset Compute-arbetare kan användas för att skriva tillbaka metadata till resurser i AEM as a Cloud Service.

Logiskt flöde för ett anrop till en Asset Compute-metadataarbetare

Anropet från Asset Compute metadataarbetare är nästan identiskt med anropet från binära återgivningsarbetare, där den primära skillnaden är returtypen är en XMP (XML)-återgivning vars värden också skrivs till resursens metadata.

Asset Compute-arbetare implementerar Asset Compute SDK-arbets-API-kontraktet i funktionen renditionCallback(...) som är begreppsmässigt:

Konfigurera manifest.yml manifest

Alla Asset Compute-arbetare måste registreras i manifest.yml.

Öppna projektets manifest.yml och lägg till en arbetarpost som konfigurerar den nya arbetaren, i det här fallet metadata-colors.

Kom ihåg att .yml är blankstegskänslig.

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 pekar på den arbetarimplementering som skapades i nästa steg. Namnge arbetare semantiskt (till exempel kan actions/worker/index.js ha fått ett bättre namn actions/rendition-circle/index.js), eftersom dessa visas i arbetarens URL och även fastställer arbetarens testsvitsmapp.

limits och require-adobe-auth har konfigurerats separat per arbetare. I den här arbetaren tilldelas 512 MB minne när koden undersöker (eventuellt) stora binära bilddata. De andra limits har tagits bort för att använda standardvärden.

Utveckla en metadataarbetare metadata-worker

Skapa en ny JavaScript-fil för metadataarbetare i Asset Compute-projektet på sökvägen defined manifest.yml för den nya arbetaren, på /actions/metadata-colors/index.js

Installera npm-moduler

Installera de extra npm-modulerna (@adobe/asset-compute-xmp, get-image-colors och color-namer) som används i den här Asset Compute-arbetaren.

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

Metadata worker code

Den här arbetaren ser ut ungefär som den återgivningsgenererande arbetaren. Den största skillnaden är att den skriver XMP-data (XML) till rendition.path för att sparas i AEM igen.

"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; }
}

Kör metadataarbetaren lokalt development-tool

När koden är klar kan den köras med det lokala Asset Compute Development Tool.

Eftersom vårt Asset Compute-projekt innehåller två arbetare (den tidigare cirkelrenderingen och den här metadata-colors arbetaren) listas körningsprofiler för båda arbetarna i Asset Compute Development Tool -profildefinitionen. Den andra profildefinitionen pekar på den nya metadata-colors-arbetaren.

Testa arbetaren test

Metadataarbetare kan testas med samma Asset Compute-testramverk som binära återgivningar. Den enda skillnaden är att filen rendition.xxx i testfallet måste vara den förväntade XMP-återgivningen (XML).

Distribuera arbetaren till Adobe I/O Runtime deploy

Om du vill anropa den här nya metadataarbetaren från AEM Assets måste den distribueras till Adobe I/O Runtime med kommandot:

$ aio app deploy

Observera att detta distribuerar alla arbetare i projektet. Granska de ej förkortade distributionsinstruktionerna för hur du distribuerar till arbetsytorna Stage och Production.

Integrera med AEM bearbetningsprofiler processing-profile

Anropa arbetaren från AEM genom att skapa en ny, eller ändra en befintlig, anpassad bearbetningsprofiltjänst som anropar den här distribuerade arbetaren.

Uppdatera metadataschemat metadata-schema

Om du vill granska färgmetadata mappar du två nya fält i bildens metadataram till de nya metadataegenskaper som arbetaren fyller i.

Bearbetar resurser

När färgmetadata skrivs till resursens metadata på [dam:Asset]/jcr:content/metadata-resursen indexeras den här metadata, vilket gör det möjligt att identifiera resurser med dessa termer via sökning. De kan även skrivas tillbaka till resursens binärfil om DAM Metadata Writeback -arbetsflödet anropas.

Metadataåtergivning i AEM Assets

Den XMP-fil som genereras av Asset Compute metadataarbetare lagras också som en separat återgivning av resursen. Den här filen används vanligtvis inte, i stället används de värden som används för objektets metadatanod, men rå XML-utdata från arbetaren är tillgängliga i AEM.

metadata-colors worker code on Github

Den sista metadata-colors/index.js är tillgänglig på Github på:

Den sista test/asset-compute/metadata-colors-testsviten är tillgänglig på Github på: