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:
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 em ativos no AEM as a Cloud Service.
A invocação de trabalhadores de metadados de Asset compute é quase idêntica à de representação binária que gera trabalhadores, sendo a principal diferença o tipo de retorno, é 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, no renditionCallback(...)
conceitualmente:
renditionCallback(...)
função, derivando uma representação XMP (XML), com base no binário do ativo (1-A) e qualquer parâmetro do perfil de processamento (1-B).rendition.path
.rendition.path
é transportado via SDK do Asset compute para o AEM Author Service e o expõe como (4-A) uma representação de texto e 4-B) persistida no nó de metadados do ativo.Todos os trabalhadores Assets compute devem estar registrados na manifest.yml.
Abra o manifest.yml
e adicionar uma entrada de trabalhador que configura o novo trabalhador, neste caso metadata-colors
.
Lembrar .yml
O 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 do trabalhador criada na próxima etapa. Nomeie os trabalhadores semanticamente (por exemplo, o actions/worker/index.js
pode ter sido melhor nomeado actions/rendition-circle/index.js
), como estes mostram no URL do trabalhador e também determinar a nome da pasta do conjunto de testes do trabalhador.
A variável limits
e require-adobe-auth
são configurados discretamente por funcionário. Neste trabalhador, 512 MB
de memória é alocada à medida que o código inspeciona (potencialmente) dados de imagens binárias grandes. O outro limits
são removidos para usar os padrões.
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 os módulos npm extras (@adobe/asset-compute-xmp, get-image-colors, e color-namer) que é usado neste trabalhador do Asset compute.
$ npm install @adobe/asset-compute-xmp
$ npm install get-image-colors
$ npm install color-namer
Esse trabalhador é muito semelhante ao trabalhador que gera 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; }
}
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 (o anterior representação circular e este metadata-colors
trabalhador), a Ferramentas de desenvolvimento do Asset compute a definição do perfil lista os perfis de execução de ambos os trabalhadores. A segunda definição de perfil aponta para o novo metadata-colors
trabalhador.
Na raiz do projeto do Asset compute
Executar aio app run
para iniciar a Ferramenta de desenvolvimento do Asset compute
No Selecione um arquivo… selecione um imagem de amostra para processar
Na segunda configuração de definição de perfil, que aponta para a variável metadata-colors
trabalhador, atualizar "name": "rendition.xml"
conforme esse trabalhador gera uma representação XMP (XML). Opcionalmente, adicione um colorsFamily
parâmetro do (valores suportados) basic
, hex
, html
, ntc
, pantone
, roygbiv
).
{
"renditions": [
{
"worker": "...",
"name": "rendition.xml",
"colorsFamily": "pantone"
}
]
}
Toque Executar e aguardar a geração da representação XML
A variável Representações pré-visualiza a representação gerada. Toque no rendition.xml
para baixá-lo e abri-lo no VS Code (ou no editor de texto/XML favorito) para revisão.
Os trabalhadores de metadados podem ser testados usando o mesma estrutura de teste de Asset compute que representações binárias. A única diferença é a rendition.xxx
o arquivo no caso de teste deve ser a representação XMP (XML) esperada.
Crie a seguinte estrutura no projeto do Asset compute:
/test/asset-compute/metadata-colors/success-pantone/
file.jpg
params.json
rendition.xml
Use o arquivo de amostra como do caso de teste file.jpg
.
Adicione o seguinte JSON à params.json
.
{
"fmt": "xml",
"colorsFamily": "pantone"
}
Observe que "fmt": "xml"
é necessário instruir o conjunto de testes para gerar uma .xml
representação baseada em texto.
Forneça o XML esperado no rendition.xml
arquivo. Isso pode ser obtido por:
<?xml version="1.0" encoding="UTF-8"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:wknd="https://wknd.site/assets/1.0/"><rdf:Description><wknd:colors><rdf:Seq><rdf:li>Silver</rdf:li><rdf:li>Black</rdf:li><rdf:li>Outer Space</rdf:li></rdf:Seq></wknd:colors><wknd:colorsFamily>pantone</wknd:colorsFamily></rdf:Description></rdf:RDF>
Executar aio app test
na raiz do projeto do Asset compute para executar todos os conjuntos de testes.
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 o instruções de implantação não resumida para saber como implantar em espaços de trabalho de Preparo e Produção.
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.
https://...adobeioruntime.net/api/v1/web/wkndAemAssetCompute-0.0.1/metadata-colors
aio app get-url
. Verifique se o URL aponta para o espaço de trabalho correto com base no ambiente as a Cloud Service AEM.colorFamily
pantone
basic
, hex
, html
, ntc
, pantone
, roygbiv
image/jpeg
, image/png
, image/gif
, image/svg
Leave blank
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.
Colors Family
./jcr:content/metadata/wknd:colorsFamily
Colors
./jcr:content/metadata/wknd:colors
Colors Family
e Colors
campos de metadados para os metadados gravados do worker de metadados do Asset compute personalizado.Com os metadados de cores gravados nos metadados do ativo, no [dam:Asset]/jcr:content/metadata
recurso, esses metadados são indexados como maior capacidade de descoberta de ativos usando esses termos por meio de pesquisa, e podem até ser gravados no binário do ativo se Writeback de metadados DAM fluxo de trabalho é chamado nela.
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.
A versão final metadata-colors/index.js
está disponível no Github em:
A versão final test/asset-compute/metadata-colors
o conjunto de testes está disponível no Github em: