Los Assets computes personalizados pueden producir XMP datos (XML) que se envían de vuelta a AEM y se almacenan como metadatos en un recurso.
Los casos de uso comunes incluyen:
En este tutorial, crearemos un programa de trabajo de metadatos de Asset compute que deriva los colores más utilizados en un recurso de imagen y escribe los nombres de los colores en los metadatos del recurso en AEM. Aunque el propio trabajador es básico, este tutorial lo utiliza para explorar cómo se pueden utilizar los trabajadores de Asset compute para escribir metadatos en los recursos de AEM as a Cloud Service.
La invocación de los trabajadores de metadatos de Asset compute es casi idéntica a la de trabajadores generadores de representaciones binarias, con la diferencia principal de que el tipo devuelto es una representación XMP (XML) cuyos valores también se escriben en los metadatos del recurso.
Los trabajadores de asset compute implementan el contrato de la API de trabajo del SDK de Asset compute en el renditionCallback(...)
, que es conceptualmente:
renditionCallback(...)
, derivando una representación XMP (XML), basada en el binario del recurso (1 bis) y cualquier parámetro de perfil de procesamiento (1 ter).rendition.path
.rendition.path
se transporta a través del SDK de Asset compute al servicio de AEM Author y lo expone como (4 bis) una representación de texto y (4 ter) persistió en el nodo de metadatos del recurso.Todos los Assets computes deben estar registrados en la manifest.yml.
Abra el manifest.yml
y añada una entrada de trabajador que configure el nuevo trabajador, en este caso metadata-colors
.
Recordar .yml
distingue entre espacios en blanco.
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
apunta a la implementación del trabajador creada en la variable paso siguiente. Asigne un nombre semántico a los trabajadores (por ejemplo, la variable actions/worker/index.js
puede haber sido mejor nombrado actions/rendition-circle/index.js
), tal y como se muestran en la variable URL del trabajador y también determinan el nombre de la carpeta del grupo de pruebas del trabajador.
La variable limits
y require-adobe-auth
se configuran de forma discreta por trabajador. En este trabajador, 512 MB
de memoria se asigna a medida que el código inspecciona (potencialmente) los grandes datos de imagen binaria. El otro limits
se eliminan para utilizar valores predeterminados.
Cree un nuevo archivo JavaScript de trabajo de metadatos en el proyecto de Asset compute en la ruta manifest.yml definido para el nuevo trabajador, en /actions/metadata-colors/index.js
Instale los módulos npm adicionales (@adobe/asset-compute-xmp, get-image-colorsy color-namer) que se utiliza en este programa de trabajo de Asset compute.
$ npm install @adobe/asset-compute-xmp
$ npm install get-image-colors
$ npm install color-namer
Este trabajador se parece mucho a la variable trabajador generador de representaciones, la diferencia principal es que escribe XMP datos (XML) en el rendition.path
para volver a guardarse en 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; }
}
Una vez completado el código de trabajo, se puede ejecutar mediante la herramienta de desarrollo de Asset compute local.
Como nuestro proyecto de Asset compute contiene dos trabajadores (el anterior representación de círculo y metadata-colors
trabajador), Herramienta de desarrollo de assets computes la definición de perfil enumera los perfiles de ejecución para ambos trabajadores. La segunda definición de perfil apunta a la nueva metadata-colors
de trabajo.
Desde la raíz del proyecto de Asset compute
Ejecutar aio app run
para iniciar la herramienta de desarrollo de Asset compute
En el Seleccionar un archivo… desplegable, elija un imagen de ejemplo para procesar
En la segunda configuración de definición de perfil, que señala a la variable metadata-colors
trabajador, actualizar "name": "rendition.xml"
a medida que este trabajador genera una representación XMP (XML). De forma opcional, agregue un colorsFamily
parámetro (valores admitidos) basic
, hex
, html
, ntc
, pantone
, roygbiv
).
{
"renditions": [
{
"worker": "...",
"name": "rendition.xml",
"colorsFamily": "pantone"
}
]
}
Toque Ejecutar y esperar a que se genere la representación XML
La variable Representaciones previsualiza la representación generada. Toque . rendition.xml
para descargarlo y abrirlo en el código VS (o su editor de texto/XML favorito) para revisarlo.
Los trabajadores de metadatos se pueden probar utilizando la variable el mismo marco de pruebas de Asset compute que las representaciones binarias. La única diferencia es que rendition.xxx
en el caso de prueba debe ser la representación XMP (XML) esperada.
Cree la siguiente estructura en el proyecto de Asset compute:
/test/asset-compute/metadata-colors/success-pantone/
file.jpg
params.json
rendition.xml
Utilice la variable archivo de muestra como caso de prueba file.jpg
.
Añada el siguiente JSON al params.json
.
{
"fmt": "xml",
"colorsFamily": "pantone"
}
Tenga en cuenta que "fmt": "xml"
es necesario para solicitar al grupo de prueba que genere un .xml
representación basada en texto.
Proporcione el XML esperado en la variable rendition.xml
archivo. Esto puede obtenerse mediante:
<?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>
Ejecutar aio app test
desde la raíz del proyecto de Asset compute para ejecutar todos los grupos de pruebas.
Para invocar este nuevo trabajador de metadatos de AEM Assets, debe implementarse en Adobe I/O Runtime mediante el comando :
$ aio app deploy
Tenga en cuenta que esto implementará todos los trabajadores del proyecto. Consulte la instrucciones de implementación no abreviadas para saber cómo implementar en espacios de trabajo de fase y producción.
Invoque el trabajador de AEM creando un nuevo servicio de perfil de procesamiento personalizado existente que invoque a este trabajador implementado o modificándolo.
https://...adobeioruntime.net/api/v1/web/wkndAemAssetCompute-0.0.1/metadata-colors
aio app get-url
. Asegúrese de que la dirección URL señale al espacio de trabajo correcto en función del entorno 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 los metadatos de colores, asigne dos campos nuevos en el esquema de metadatos de la imagen a las nuevas propiedades de datos de metadatos que rellena el trabajador.
Colors Family
./jcr:content/metadata/wknd:colorsFamily
Colors
./jcr:content/metadata/wknd:colors
Colors Family
y Colors
campos de metadatos para los metadatos que se vuelven a escribir desde el Asset compute de trabajo de metadatos personalizado.Con los metadatos de color escritos en los metadatos del recurso, en la variable [dam:Asset]/jcr:content/metadata
recurso, estos metadatos se indexan con una mayor capacidad de detección de recursos mediante el uso de estos términos mediante la búsqueda, e incluso se pueden escribir en el binario del recurso si Reescritura de metadatos DAM se invoca al flujo de trabajo.
El archivo de XMP generado por el trabajador de metadatos de Asset compute también se almacena como una representación discreta en el recurso. Normalmente, este archivo no se utiliza, sino que se utilizan los valores aplicados al nodo de metadatos del recurso, pero la salida XML sin procesar del trabajo está disponible en AEM.
El final metadata-colors/index.js
está disponible en Github en:
El final test/asset-compute/metadata-colors
el grupo de pruebas está disponible en Github en: