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:
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 worker è di base, questo tutorial lo utilizza per esplorare il modo in cui i worker Asset compute possono essere utilizzati per riscrivere i metadati nelle risorse in AEM as a Cloud Service.
Il richiamo dei processi di lavoro dei metadati Asset compute è quasi identico a quello di rendering binario che genera i processi di lavoro, dove la differenza principale è il tipo restituito è una rappresentazione XMP (XML) i cui valori vengono scritti anche nei metadati della risorsa.
Asset compute worker implementa il contratto Asset compute SDK worker API, nel renditionCallback(...)
funzione, che è concettualmente:
renditionCallback(...)
funzione, derivando una rappresentazione XMP (XML), in base al binario della risorsa (1 bis) ed eventuali parametri del profilo di elaborazione (1 ter).rendition.path
.rendition.path
viene trasportato tramite l’SDK di Asset compute al servizio AEM Author e lo espone come (4 bis) una rappresentazione del testo e (4 ter) persistente nel nodo di metadati della risorsa.Tutti i lavoratori Asset compute devono essere registrati nel manifest.yml.
Apri il file manifest.yml
e aggiungere una voce di lavoratore che configura il nuovo lavoratore, in questo caso metadata-colors
.
Ricorda .yml
fa distinzione tra 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 del lavoratore creata in passaggio successivo. Denomina i lavoratori in modo semantico (ad esempio, il actions/worker/index.js
potrebbe essere stato chiamato meglio actions/rendition-circle/index.js
), come mostrato nella URL del lavoratore e determinano anche nome cartella suite di test del lavoratore.
Il limits
e require-adobe-auth
sono configurate in modo discreto per lavoratore. In questo lavoratore, 512 MB
viene allocata una quantità di memoria in quanto il codice controlla (potenzialmente) i dati di grandi dimensioni dell’immagine binaria. L'altro limits
vengono rimossi per utilizzare i valori predefiniti.
Crea un nuovo file JavaScript di metadata worker nel progetto Asset compute nel percorso manifest.yml definito per il nuovo lavoratore, in corrispondenza di /actions/metadata-colors/index.js
Installare i moduli npm aggiuntivi (@adobe/asset-compute-xmp, get-image-colors, e color-namer) utilizzato in questo processo di lavoro di Asset compute.
$ npm install @adobe/asset-compute-xmp
$ npm install get-image-colors
$ npm install color-namer
Questo processo di lavoro è molto simile al processo di lavoro che genera copie trasformate, la differenza principale consiste nel fatto che scrive i dati XMP (XML) in rendition.path
per essere salvati 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; }
}
Una volta completato, il codice del processo di lavoro può essere eseguito utilizzando lo strumento di sviluppo Asset compute locale.
Perché il nostro progetto di Asset compute contiene due lavoratori (il precedente copia trasformata circolare e questo metadata-colors
lavoratore), Strumenti per lo sviluppo Asset compute nella definizione del profilo sono elencati i profili di esecuzione per entrambi i processi di lavoro. La seconda definizione di profilo punta al nuovo metadata-colors
lavoratore.
Dalla directory principale del progetto Asset compute
Esegui aio app run
per avviare lo strumento di sviluppo Asset compute
In Seleziona un file… a discesa, scegli un immagine di esempio da elaborare
Nella seconda configurazione di definizione del profilo, che punta al metadata-colors
lavoratore, aggiornamento "name": "rendition.xml"
durante la generazione del rendering XMP (XML) da parte di questo processo di lavoro. Se necessario, aggiungi un colorsFamily
parametro (valori supportati) basic
, hex
, html
, ntc
, pantone
, roygbiv
).
{
"renditions": [
{
"worker": "...",
"name": "rendition.xml",
"colorsFamily": "pantone"
}
]
}
Tocca Esegui e attendi la generazione della rappresentazione XML
Il Rappresentazioni sezione visualizza un’anteprima della rappresentazione generata. Tocca il rendition.xml
per scaricarlo e aprirlo in VS Code (o nel tuo editor XML/di testo preferito) per rivederlo.
I processi di lavoro dei metadati possono essere testati utilizzando stesso Asset compute di framework di test delle rappresentazioni binarie. L'unica differenza è rendition.xxx
Il file nel test case deve essere il rendering XMP (XML) previsto.
Crea la seguente struttura nel progetto Asset compute:
/test/asset-compute/metadata-colors/success-pantone/
file.jpg
params.json
rendition.xml
Utilizza il file di esempio come test case file.jpg
.
Aggiungi il seguente JSON a params.json
.
{
"fmt": "xml",
"colorsFamily": "pantone"
}
Osserva "fmt": "xml"
è necessario per istruire la suite di test a generare un .xml
rendering basato su testo.
Fornisci il codice XML previsto in rendition.xml
file. Tale risultato può essere ottenuto:
<?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>
Esegui aio app test
dalla directory principale del progetto Asset compute per eseguire tutte le suite di test.
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 istruzioni di distribuzione non abbreviate come implementare nelle aree di lavoro di staging e produzione.
Richiama il lavoratore dall’AEM creando un nuovo servizio Profilo di elaborazione personalizzato esistente o modificandone uno esistente che richiama il lavoratore distribuito.
https://...adobeioruntime.net/api/v1/web/wkndAemAssetCompute-0.0.1/metadata-colors
aio app get-url
. Assicurati che l’URL punti nell’area di lavoro corretta in base all’ambiente as a Cloud Service dall’AEM.colorFamily
pantone
basic
, hex
, html
, ntc
, pantone
, roygbiv
image/jpeg
, image/png
, image/gif
, image/svg
Leave blank
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.
Colors Family
./jcr:content/metadata/wknd:colorsFamily
Colors
./jcr:content/metadata/wknd:colors
Colors Family
e Colors
campi metadati per i metadati riscritti dal processo di lavoro metadati Asset compute personalizzato.Con i metadati del colore scritti nei metadati della risorsa, nella [dam:Asset]/jcr:content/metadata
risorsa, questi metadati sono indicizzati per migliorarne la funzionalità di individuazione tramite ricerca e possono anche essere riscritti nel file binario della risorsa Writeback di metadati DAM il flusso di lavoro viene richiamato.
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.
La versione finale metadata-colors/index.js
è disponibile su Github all’indirizzo:
La versione finale test/asset-compute/metadata-colors
la suite di test è disponibile su Github all’indirizzo: