Toegangstoken lokale ontwikkeling

Ontwikkelaars die integraties bouwen die programmatische toegang tot AEM as a Cloud Service vereisen, hebben een eenvoudige, snelle manier nodig om tijdelijke toegangstokens voor AEM te verkrijgen om lokale ontwikkelingsactiviteiten te vergemakkelijken. Om aan deze behoefte te voldoen, staat AEM Developer Console ontwikkelaars toe om tijdelijke toegangstokens zelf te produceren die aan programmatically tot AEM kunnen worden gebruikt toegang te hebben.

Een token voor lokale ontwikkelingstoegang genereren

het krijgen van een Lokaal Token van de Toegang van de Ontwikkeling

Het lokale Token van de Toegang van de Ontwikkeling verleent toegang tot AEM Auteur en de diensten van Publish als gebruiker die het teken, samen met hun toestemmingen produceerde. Ondanks dat dit een ontwikkelingstoken is, deel dit teken niet, of opslag in broncontrole.

  1. In Adobe Admin Consoleverzekert u, de ontwikkelaar, een lid van zijn:

    • Cloud Manager - het Profiel van het Product IMS van de Ontwikkelaar (verleent toegang tot AEM Developer Console)
    • Of de AEM Beheerders of AEM het Profiel van het Product van Gebruikers IMS voor de dienst van het AEM milieu het toegangstoken integreert met
    • Het milieu van de zandbak AEM as a Cloud Service vereist slechts lidmaatschap in of AEM Beheerders of AEM Gebruikers Profiel van het Product
  2. Login aan Adobe Cloud Manager

  3. Open het programma dat de AEM as a Cloud Service-omgeving bevat om mee te integreren

  4. Tik de ellips naast het milieu in de sectie van Milieu, en selecteer Developer Console

  5. Tik in het lusje van de Integraties

  6. Tik het Lokale teken lusje

  7. Teken van de Ontwikkeling van het Teken van de Tik van het Tik krijgen Lokale

  8. Tik op de downloadknoop in de hoogste-linkerhoek om het JSON dossier te downloaden dat accessToken waarde bevat, en sparen het JSON dossier aan een veilige plaats op uw ontwikkelingsmachine.

    • Dit is uw 24-uurs toegangstoken voor ontwikkelaars tot de AEM as a Cloud Service-omgeving.

AEM Developer Console - Integraties - krijg de Token van de Lokale Ontwikkeling

Gebruikt het Lokale Token van de Toegang van de Ontwikkeling use-local-development-access-token

Token van de Toegang van de Lokale Ontwikkeling - Externe Toepassing

  1. Download het tijdelijke Local Development Access Token van AEM Developer Console
    • De lokale Token van de Toegang van de Ontwikkeling verloopt om de 24 uur, zodat moeten de ontwikkelaars nieuwe toegangstokens dagelijks downloaden
  2. Er wordt een externe toepassing ontwikkeld die programmatisch communiceert met AEM as a Cloud Service
  3. De externe toepassing leest in het Token van de Toegang van de Lokale Ontwikkeling
  4. De externe toepassing construeert HTTP- verzoeken aan AEM as a Cloud Service, die het Lokale Token van de Toegang van de Ontwikkeling als teken van de Drager aan de kopbal van de Vergunning van HTTP- verzoeken toevoegen
  5. AEM as a Cloud Service ontvangt de HTTP-aanvraag, verifieert de aanvraag en voert het werk uit dat door de HTTP-aanvraag wordt aangevraagd en retourneert een HTTP-reactie terug naar de externe toepassing

De externe voorbeeldtoepassing

Wij zullen een eenvoudige externe toepassing van JavaScript tot stand brengen om te illustreren hoe te om tot AEM as a Cloud Service over HTTPS programmatically toegang te hebben gebruikend het lokale toegangstoken van de ontwikkelaar. Dit illustreert hoe om het even welke toepassing of systeem dat buiten AEM, ongeacht kader of taal loopt, het toegangstoken kan gebruiken programmatically voor authentiek te verklaren aan, en toegang te hebben, AEM as a Cloud Service. In de volgende sectie, zullen wij deze toepassingscode bijwerken om de benadering te steunen voor het produceren van een teken voor productiegebruik.

Deze voorbeeldtoepassing wordt uitgevoerd vanaf de opdrachtregel en werkt metagegevens AEM elementen bij met behulp van AEM Assets HTTP-API's. Hierbij wordt de volgende stroom gebruikt:

  1. Leest in parameters van de bevellijn (getCommandLineParams())
  2. Verkrijgt het toegangstoken dat wordt gebruikt om aan AEM as a Cloud Service (getAccessToken(...)) voor authentiek te verklaren
  3. Maakt een lijst van alle activa in een AEM middelomslag die in een bevel-lijn parameters wordt gespecificeerd (listAssetsByFolder(...))
  4. De meta-gegevens van de vermelde activa met waarden bijwerken die in bevel-lijn parameters worden gespecificeerd (updateMetadata(...))

Het belangrijkste element in programmatically het voor authentiek verklaren aan AEM gebruikend het toegangstoken voegt een de verzoekkopbal van HTTP van de Vergunning aan alle HTTP- verzoeken toe die aan AEM worden gemaakt, in het volgende formaat:

  • Authorization: Bearer ACCESS_TOKEN

De externe toepassing uitvoeren

  1. Zorg ervoor dat Node.jsop uw lokale ontwikkelingsmachine geïnstalleerd is, die wordt gebruikt om de externe toepassing in werking te stellen

  2. De download en unzip de steekproef externe toepassing

  3. Voer vanuit de opdrachtregel in de map van dit project npm install uit

  4. Kopieer het Lokale Token van de Toegang van de Ontwikkelingaan een dossier genoemd local_development_token.json in de wortel van het project

    • Maar vergeet niet dat u nooit aanmeldgegevens aan Git wilt toewijzen!
  5. Open index.js en bekijk de code en opmerkingen van de externe toepassing.

    code language-javascript
    const fetch = require('node-fetch');
    const fs = require('fs');
    const auth = require('@adobe/jwt-auth');
    
    // The root context of the Assets HTTP API
    const ASSETS_HTTP_API = '/api/assets';
    
    // Command line parameters
    let params = { };
    
    /**
    * Application entry point function
    */
    (async () => {
        console.log('Example usage: node index.js aem=https://author-p1234-e5678.adobeaemcloud.com propertyName=metadata/dc:rights "propertyValue=WKND Limited Use" folder=/wknd-shared/en/adventures/napa-wine-tasting file=credentials-file.json' );
    
        // Parse the command line parameters
        params = getCommandLineParams();
    
        // Set the access token to be used in the HTTP requests to be local development access token
        params.accessToken = await getAccessToken(params.developerConsoleCredentials);
    
        // Get a list of all the assets in the specified assets folder
        let assets = await listAssetsByFolder(params.folder);
    
        // For each asset, update it's metadata
        await assets.forEach(asset => updateMetadata(asset, {
            [params.propertyName]: params.propertyValue
        }));
    })();
    
    /**
    * Returns a list of Assets HTTP API asset URLs that reference the assets in the specified folder.
    *
    * https://experienceleague.adobe.com/docs/experience-manager-cloud-service/assets/admin/mac-api-assets.html?lang=en#retrieve-a-folder-listing
    *
    * @param {*} folder the Assets HTTP API folder path (less the /content/dam path prefix)
    */
    async function listAssetsByFolder(folder) {
        return fetch(`${params.aem}${ASSETS_HTTP_API}${folder}.json`, {
                method: 'get',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': 'Bearer ' + params.accessToken // Provide the AEM access token in the Authorization header
                },
            })
            .then(res => {
                console.log(`${res.status} - ${res.statusText} @ ${params.aem}${ASSETS_HTTP_API}${folder}.json`);
    
                // If success, return the JSON listing assets, otherwise return empty results
                return res.status === 200 ? res.json() : { entities: [] };
            })
            .then(json => {
                // Returns a list of all URIs for each non-content fragment asset in the folder
                return json.entities
                    .filter((entity) => entity['class'].indexOf('asset/asset') === -1 && !entity.properties.contentFragment)
                    .map(asset => asset.links.find(link => link.rel.find(r => r === 'self')).href);
            });
    }
    
    /**
    * Update the metadata of an asset in AEM
    *
    * https://experienceleague.adobe.com/docs/experience-manager-cloud-service/assets/admin/mac-api-assets.html?lang=en#update-asset-metadata
    *
    * @param {*} asset the Assets HTTP API asset URL to update
    * @param {*} metadata the metadata to update the asset with
    */
    async function updateMetadata(asset, metadata) {
        await fetch(`${asset}`, {
                method: 'put',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': 'Bearer ' + params.accessToken // Provide the AEM access token in the Authorization header
                },
                body: JSON.stringify({
                    class: 'asset',
                    properties: metadata
                })
            })
            .then(res => {
                console.log(`${res.status} - ${res.statusText} @ ${asset}`);
            });
    }
    
    /**
    * Parse and return the command line parameters. Expected params are:
    *
    * - aem = The AEM as a Cloud Service hostname to connect to.
    *              Example: https://author-p12345-e67890.adobeaemcloud.com
    * - folder = The asset folder to update assets in. Note that the Assets HTTP API do NOT use the JCR `/content/dam` path prefix.
    *              Example: '/wknd-shared/en/adventures/napa-wine-tasting'
    * - propertyName = The asset property name to update. Note this is relative to the [dam:Asset]/jcr:content node of the asset.
    *              Example: metadata/dc:rights
    * - propertyValue = The value to update the asset property (specified by propertyName) with.
    *              Example: "WKND Free Use"
    * - file = The path to the JSON file that contains the credentials downloaded from AEM Developer Console
    *              Example: local_development_token_cm_p1234-e5678.json
    */
    function getCommandLineParams() {
        let parameters = {};
    
        // Parse the command line params, splitting on the = delimiter
        for (let i = 2; i < process.argv.length; i++) {
            let key = process.argv[i].split('=')[0];
            let value = process.argv[i].split('=')[1];
    
            parameters[key] = value;
        };
    
        // Read in the credentials from the provided JSON file
        if (parameters.file) {
            parameters.developerConsoleCredentials = JSON.parse(fs.readFileSync(parameters.file));
        }
    
        console.log(parameters);
    
        return parameters;
    }
    
    async function getAccessToken(developerConsoleCredentials) {s
        if (developerConsoleCredentials.accessToken) {
            // This is a Local Development access token
            return developerConsoleCredentials.accessToken;
        }
    }
    

    Controleer de fetch(..) aanroepen in de listAssetsByFolder(...) en updateMetadata(...) en headers definieer de Authorization HTTP-aanvraagheader met de waarde Bearer ACCESS_TOKEN . Zo wordt de HTTP-aanvraag van de externe toepassing geverifieerd bij AEM as a Cloud Service.

    code language-javascript
    ...
    return fetch(`${params.aem}${ASSETS_HTTP_API}${folder}.json`, {
                method: 'get',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': 'Bearer ' + params.accessToken // Provide the AEM access token in the Authorization header
                },
    })...
    

    Om het even welke HTTP- verzoeken aan AEM as a Cloud Service, moeten het toegangstoken van de Drager in de kopbal van de Vergunning plaatsen. Herinner me, vereist elke milieu van AEM as a Cloud Service zijn eigen toegangstoken. De toegangstoken van de ontwikkeling werkt niet op Stadium of Productie, het Stadium werkt niet aan Ontwikkeling of Productie, en Productie werkt niet op Ontwikkeling of Stadium!

  6. Gebruikend de bevellijn, van de wortel van het project voert de toepassing uit, die in de volgende parameters overgaat:

    code language-shell
    $ node index.js \
        aem=https://author-p1234-e5678.adobeaemcloud.com \
        folder=/wknd-shared/en/adventures/napa-wine-tasting \
        propertyName=metadata/dc:rights \
        propertyValue="WKND Limited Use" \
        file=local_development_token.json
    

    De volgende parameters worden doorgegeven:

    • aem: Het schema en de hostnaam van de AEM as a Cloud Service-omgeving waarmee de toepassing werkt (bijvoorbeeld https://author-p1234-e5678.adobeaemcloud.com ).
    • folder: Het pad naar de elementenmap waarvan de elementen met propertyValue worden bijgewerkt; voeg het voorvoegsel /content/dam NIET toe (bijv. /wknd-shared/en/adventures/napa-wine-tasting)
    • propertyName: De naam van de elementeigenschap die moet worden bijgewerkt, in verhouding tot [dam:Asset]/jcr:content (bijvoorbeeld metadata/dc:rights ).
    • propertyValue: De waarde waarop de propertyName moet worden ingesteld; waarden met spaties moeten worden ingekapseld met " (bijv. "WKND Limited Use")
    • file: Het relatieve bestandspad naar het JSON-bestand dat is gedownload van AEM Developer Console.

    Een geslaagde uitvoering van de resultaten van de toepassing voor elk bijgewerkt element:

    code language-shell
    200 - OK @ https://author-p1234-e5678.adobeaemcloud.com/api/assets/wknd-shared/en/adventures/napa-wine-tasting.json
    200 - OK @ https://author-p1234-e5678.adobeaemcloud.com/api/assets/wknd-shared/en/adventures/napa-wine-tasting/AdobeStock_277654931.jpg.json
    200 - OK @ https://author-p1234-e5678.adobeaemcloud.com/api/assets/wknd-shared/en/adventures/napa-wine-tasting/AdobeStock_239751461.jpg.json
    200 - OK @ https://author-p1234-e5678.adobeaemcloud.com/api/assets/wknd-shared/en/adventures/napa-wine-tasting/AdobeStock_280313729.jpg.json
    200 - OK @ https://author-p1234-e5678.adobeaemcloud.com/api/assets/wknd-shared/en/adventures/napa-wine-tasting/AdobeStock_286664352.jpg.json
    

Metagegevens bijwerken in AEM controleren

Controleer of de metagegevens zijn bijgewerkt door u aan te melden bij de AEM as a Cloud Service-omgeving (zorg ervoor dat dezelfde host die is doorgegeven aan de opdrachtregelparameter aem wordt benaderd).

  1. Meld u aan bij de AEM as a Cloud Service-omgeving waarmee de externe toepassing interactie heeft gehad (gebruik dezelfde host als in de opdrachtregelparameter van aem )
  2. Ga aan Assets > Dossiers
  3. Navigeer het de activaomslag die door de folder bevel-lijn parameter, bijvoorbeeld wordt gespecificeerd WKND > Engels > avonturen > het Tasting van de Wijn van Napa
  4. Open Eigenschappen voor om het even welk (niet-Inhoud Fragment) activa in de omslag
  5. Tik aan het Geavanceerde lusje
  6. Herzie de waarde van het bijgewerkte bezit, bijvoorbeeld Copyright dat aan het bijgewerkte metadata/dc:rights bezit JCR in kaart wordt gebracht, dat op de waarde wijst die in de propertyValue parameter wordt verstrekt, bijvoorbeeld Beperkt Gebruik WKND

WKND de Beperkte Update van Metagegevens van het Gebruik

Volgende stappen

Nu we AEM as a Cloud Service via programmacode hebben benaderd met het token voor lokale ontwikkeling. Vervolgens moet de toepassing worden bijgewerkt zodat deze kan worden gebruikt in een productiecontext.

recommendation-more-help
e25b6834-e87f-4ff3-ba56-4cd16cdfdec4