Sviluppa un Asset compute di processo di lavoro per metadati

Gli Asset compute personalizzati possono produrre dati XMP (XML) che vengono rimandati all'AEM e memorizzati come metadati su una risorsa.

I casi d’uso comuni includono:

Come procedere

In questo tutorial verrà creato un processo di lavoro dei metadati di Asset Compute che deriva i colori più comunemente utilizzati in una risorsa immagine e riscrive i nomi dei colori nei metadati della risorsa in AEM. Anche se il processo di lavoro è di base, questo tutorial lo utilizza per esplorare il modo in cui i processi di lavoro Asset Compute possono essere utilizzati per riscrivere i metadati nelle risorse in AEM as a Cloud Service.

Flusso logico di una chiamata di lavoro di metadati Asset Compute

Il richiamo dei processi di lavoro dei metadati Asset Compute è quasi identico a quello di rendering binario che genera processi di lavoro. La differenza principale è che il tipo restituito è un rendering XMP (XML) i cui valori vengono scritti anche nei metadati della risorsa.

I processi di lavoro Asset Compute implementano il contratto Asset Compute SDK worker API nella funzione renditionCallback(...), concettualmente:

Configurare manifest.yml manifest

Tutti i lavoratori Asset compute devono essere registrati in manifest.yml.

Aprire manifest.yml del progetto e aggiungere una voce di processo che configura il nuovo processo di lavoro, in questo caso metadata-colors.

Ricorda che .yml è sensibile agli spazi.

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 punta all'implementazione di lavoro creata nel passaggio successivo. Denomina i processi di lavoro in modo semantico (ad esempio, actions/worker/index.js potrebbe essere stato denominato actions/rendition-circle/index.js), in quanto vengono visualizzati nell'URL del processo di lavoro e determinano anche il nome della cartella della suite di test del processo di lavoro.

limits e require-adobe-auth sono configurati in modo discreto per lavoratore. In questo processo di lavoro, 512 MB di memoria viene allocata in quanto il codice controlla (potenzialmente) i dati di immagini binarie di grandi dimensioni. Gli altri limits vengono rimossi per utilizzare i valori predefiniti.

Sviluppare un processo di lavoro metadati metadata-worker

Crea un nuovo file JavaScript del processo di lavoro metadati nel progetto Asset Compute nel percorso defined manifest.yml per il nuovo processo di lavoro, in /actions/metadata-colors/index.js

Installare i moduli npm

Installa i moduli npm aggiuntivi (@adobe/asset-compute-xmp, get-image-colors e color-namer) utilizzati in questo processo di lavoro di Asset compute.

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

Codice processo metadati

Questo processo di lavoro è molto simile al processo di lavoro che genera copie trasformate. La differenza principale è che scrive i dati XMP (XML) in rendition.path per essere salvato nuovamente in 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; }
}

Esegui il processo di lavoro metadati localmente development-tool

Una volta completato, il codice del processo di lavoro può essere eseguito utilizzando lo strumento di sviluppo Asset compute locale.

Poiché il progetto di Asset compute contiene due processi di lavoro (il precedente rendering circolare e questo processo di lavoro metadata-colors), la definizione del profilo 🔗 dello strumento di sviluppo Asset compute elenca i profili di esecuzione per entrambi i processi di lavoro. La seconda definizione di profilo punta al nuovo processo di lavoro metadata-colors.

Verifica il lavoratore test

I processi di lavoro dei metadati possono essere testati utilizzando lo stesso framework di test Asset compute delle rappresentazioni binarie. L'unica differenza è che il file rendition.xxx nel test case deve essere il rendering XMP (XML) previsto.

Distribuire il processo di lavoro in Adobe I/O Runtime deploy

Per richiamare questo nuovo processo di lavoro metadati da AEM Assets, è necessario distribuirlo a Adobe I/O Runtime utilizzando il comando:

$ aio app deploy

Tieni presente che verranno distribuiti tutti i processi di lavoro nel progetto. Rivedi le istruzioni di distribuzione non abbreviate per informazioni su come distribuire nelle aree di lavoro di staging e produzione.

Integrare con i profili di elaborazione dell’AEM processing-profile

Richiama il lavoratore dall’AEM creando un nuovo servizio Profilo di elaborazione personalizzato esistente o modificandone uno esistente che richiama il lavoratore distribuito.

Aggiornare lo schema metadati metadata-schema

Per rivedere i metadati dei colori, mappa due nuovi campi nello schema di metadati dell’immagine con le nuove proprietà dei dati metadati che il processo di lavoro compila.

Elaborazione delle risorse

Con i metadati del colore scritti nei metadati della risorsa, nella risorsa [dam:Asset]/jcr:content/metadata, questi metadati vengono indicizzati in modo da aumentare la capacità di individuazione della risorsa utilizzando questi termini tramite ricerca e possono anche essere riscritti nel file binario della risorsa se viene richiamato il flusso di lavoro Writeback di metadati DAM.

Rendering dei metadati in AEM Assets

Anche il file XMP effettivo generato da Asset Compute Metadata Worker viene memorizzato come rappresentazione discreta sulla risorsa. Questo file generalmente non viene utilizzato, ma vengono utilizzati i valori applicati al nodo di metadati della risorsa, ma l’output XML non elaborato del processo di lavoro è disponibile in AEM.

codice di lavoro metadati-colori su Github

Il metadata-colors/index.js finale è disponibile su Github all'indirizzo:

La suite di test test/asset-compute/metadata-colors finale è disponibile su Github all'indirizzo: