Desenvolver um trabalhador de metadados do Asset compute

Os trabalhadores de Assets compute personalizados podem produzir dados XMP (XML) que são enviados de volta para AEM e armazenados como metadados em um ativo.

Casos de uso comuns incluem:

O que você fará

Neste tutorial, criaremos um trabalhador de metadados do Asset Compute que deriva as cores mais usadas em um ativo de imagem e grava os nomes das cores de volta nos metadados do ativo no AEM. Embora o próprio trabalhador seja básico, este tutorial o usa para explorar como os trabalhadores do Asset Compute podem ser usados para gravar metadados nos ativos no AEM as a Cloud Service.

Fluxo lógico de uma invocação de trabalho de metadados de Asset compute

A invocação de trabalhadores de metadados de Asset compute é quase idêntica à de trabalhadores geradores de representação binária, sendo que a diferença primária é o tipo de retorno de uma representação XMP (XML) cujos valores também são gravados nos metadados do ativo.

Os trabalhadores do Asset Compute implementam o contrato de API do trabalhador do SDK do Asset Compute, na função renditionCallback(...), que é conceitualmente:

Configurar o manifest.yml manifest

Todos os trabalhadores do Asset compute devem estar registrados no manifest.yml.

Abra o manifest.yml do projeto e adicione uma entrada de trabalho que configure o novo trabalhador, neste caso metadata-colors.

Lembre-se de que .yml diferencia espaços em branco.

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 aponta para a implementação de trabalho criada na próxima etapa. Nomeie os trabalhadores semanticamente (por exemplo, actions/worker/index.js pode ter sido melhor nomeado como actions/rendition-circle/index.js), como eles mostram na URL do trabalhador e também determinam o nome da pasta do conjunto de testes do trabalhador.

O limits e o require-adobe-auth são configurados discretamente por trabalhador. Neste trabalho, 512 MB de memória está alocado à medida que o código inspeciona (potencialmente) dados de imagem binária grandes. Os outros limits são removidos para usar os padrões.

Desenvolver um trabalhador de metadados metadata-worker

Crie um novo arquivo JavaScript do trabalhador de metadados no projeto do Asset Compute no caminho manifest.yml definido para o novo trabalhador, em /actions/metadata-colors/index.js

Instalar módulos npm

Instale os módulos npm extras (@adobe/asset-compute-xmp, get-image-colors e color-namer) usados neste trabalho do Asset Compute.

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

Código de trabalhador de metadados

Este trabalhador é muito semelhante ao trabalhador gerador de representação. A principal diferença é que ele grava dados XMP (XML) no rendition.path para ser salvo novamente no 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; }
}

Executar o trabalho de metadados localmente development-tool

Com o código do trabalhador concluído, ele pode ser executado usando a Ferramenta de desenvolvimento de Assets compute local.

Como nosso projeto do Asset Compute contém dois workers (a representação de círculo anterior e este metadata-colors worker), a 🔗 definição de perfil da Ferramenta de Desenvolvimento do Asset Compute lista perfis de execução para ambos os workers. A segunda definição de perfil aponta para o novo trabalhador metadata-colors.

Testar o trabalhador test

Os trabalhadores de metadados podem ser testados usando a mesma estrutura de teste de Asset compute que as representações binárias. A única diferença é que o arquivo rendition.xxx no caso de teste deve ser a representação XMP (XML) esperada.

Implantar o trabalhador no Adobe I/O Runtime deploy

Para chamar esse novo trabalhador de metadados do AEM Assets, ele deve ser implantado no Adobe I/O Runtime, usando o comando:

$ aio app deploy

Observe que isso implantará todos os trabalhadores no projeto. Revise as instruções de implantação não abreviada para saber como implantar em espaços de trabalho de Preparo e Produção.

Integrar a perfis de processamento AEM processing-profile

Chame o trabalhador do AEM criando um novo serviço de perfil de processamento personalizado ou modificando um já existente que chame esse trabalhador implantado.

Atualizar o esquema de metadados metadata-schema

Para revisar os metadados de cores, mapeie dois novos campos no esquema de metadados da imagem para as novas propriedades de dados de metadados que o trabalhador preenche.

Processamento de ativos

Com os metadados de cores gravados nos metadados do ativo, no recurso [dam:Asset]/jcr:content/metadata, esses metadados são indexados por uma maior capacidade de descoberta de ativos usando esses termos por meio de pesquisa, e eles podem até ser gravados no binário do ativo se o fluxo de trabalho Writeback de metadados DAM for chamado nele.

Representação de metadados no AEM Assets

O arquivo XMP real gerado pelo trabalhador de metadados do Asset Compute também é armazenado como uma representação discreta no ativo. Esse arquivo geralmente não é usado, em vez disso, os valores aplicados ao nó de metadados do ativo são usados, mas a saída XML bruta do trabalhador está disponível no AEM.

código de trabalho de cores de metadados no Github

O metadata-colors/index.js final está disponível no Github em:

O conjunto de testes test/asset-compute/metadata-colors final está disponível no Github em: