Expand my Community achievements bar.

[AEM Gems | 19th June 2024] Improving the developer experience for AEM Assets with our new APIs and Events




Session Details

AEM developers will have the opportunity to explore the newly introduced Assets Open APIs and cloud-native I/O Events that we are offering. These advancements enable the creation of out-of-process AEM extensions. During this session, we will demonstrate how to effectively implement these tools. This demonstration will show developers how they can streamline their workflows, enhance their development speed, and reduce ongoing maintenance efforts. Additionally, we will dive into practical use cases and best practices, providing a comprehensive understanding of how these innovations can be leveraged to optimize development processes.

Housekeeping details:

  1. Duration: 60 minutes including 10 minutes of Q&A
  2. Audience: Customers, Partners, and Adobe Employees
  3. Recording and slides will be made available to the public after the session
  4. The session is free of charge, registration will be required

Session Recording

Session Schedule

Wednesday, June 19, 2024, | 8 am PDT OR 5 pm CEST OR 8.30 pm IST


Ramya Reddy, Computer Scientist at Adobe

Don't forget to register yourself for this session using the registration link shared above. 

Register at: https://adobe.ly/3wLRpdI 

Kautuk Sahni
2 Replies



Disclaimer: This content is AI-generated and may contain inaccuracies. For precise information, we recommend watching the recording.

Session Transcript:

Speaker 1: Yep. Thanks. Thanks, Gordon. Hi, everyone. I'm Ramya.

I work as an engineer in a m assets engineering team at Adobe. Welcome to this A. E. M. GEMs webinar.

In this session, you learn how to improve developer experience for A. M. Assets on cloud service. With the new asset open APIs and cloud native IO events that are introduced recently. There are similar APIs and events being built for AM sites, but we'll be looking only at the asset once in this session.

To begin, I'll discuss the issues associated with our old APIs and events along with this proposed solutions to address these challenges. Next, I'll cover a few use cases that demonstrate the integration architecture. I'll then demo how to implement one of the use cases for building an out of process AM extension using these newly introduced tools. Following that, we'll explore how to get started and use these new APIs and events, and then move to Q and A. Let's let's start with the challenges that we have with the old APIs and events.

If you have been involved with AEM, you're likely aware that the old AM APIs were developed nearly two decades ago, and developers are often overwhelmed with all the different APIs available. That is the JCR Sling, WCM, the HTTP MAC APIs. And it could be confusing for developers when determining the best practices to utilize these APIs. Developers using these APIs also need to have a deep AM expertise. For example, using a resource resolver or a session, etcetera.

Now let's let's discuss about events. AM events powered by the add on module. It refers to a legacy way of consuming AM events. Customers were required to either install this add on module on their on premise instances or deploy the same on cloud service environments. To start consuming these events.

Using these events means we need to implement in process customizations That would require deployments via cloud manager pipelines and also dependent on AM releases. Now let's look at the solutions. AM as a cloud service offers a variety of op APIs that adhere to open API specification. A modernized open API implementation of the asset APIs are available now. In pre release mode for early adoption customers.

These APIs provide all the modern tools like redoxley playground, where you can try these APIs. You'll also see common patterns across all solutions in AM For example, a problem returned in response would be consistent across assets and sides. And any developer who has worked with the HTTP APIs should be able to use these APIs and implement customizations as needed. AM cloud service events. So these are the new cloud native events that are available out of the box.

These events are routed to Adobe IO by default, and they are available instantly as soon as you subscribe to them in Adobe developer console. There is improved velocity now as it is easy to subscribe to these new events. You can also process these events according to your project needs in most lightweight, scalable, and secure ways. The most important of all, these events help to achieve out of process extensibility. That means you can avoid custom code and AM run times for better robustness and also this reduced effort when you deploy test and maintain AM as a cloud service.

Let's look at few use cases involving decisions we just discussed. Here, we can integrate AM with a third party system, such as a PIM product information management system, to update asset metadata in AM with the product information that comes from the PIM system. In this use case, when an asset is uploaded to AM and processing is completed, an asset processing completed event is generated and sent to IO events. This is then consumed by a runtime action deployed on Adobe IO. Please note you could also register a third party webhook or also integrate with Amazon Eventbridge.

We can then retrieve this product information from our PEM system in our custom runtime action and use these new asset APIs to update the product information for asset in AEM. Once this is done, customers can use this product information to search assets via SKU number and also drive business processes based on this product metadata. So this is how we achieve out of process extensibility. This is the second use case that I briefly won't discuss. When an asset is approved in AM, We want to forward this asset approval to users in a Slack channel.

When an asset is approved, that means an asset metadata updated event is generated and sent to IO events. This could be consumed by a runtime action in Adobe IO. You could also optionally get additional metadata by calling asset APIs from your runtime action. And then use this information in your notification. This way, we can inform users about certain events from AEM in external channels.

Okay. Let's get started with the demo. Firstly, I would like to show you the documentation of the new asset APIs and events. You can go to developer dot adobe dot com. And then click on explore our APIs here.

On the left, you could filter by Adobe Experience Cloud. And click on the button here for as Adobe Experience Manager. So this is the landing page for all the open APIs for AM as a cloud service. And this is the link that is of interest to us, the asset author API. This is a redoquely pre ground where you can see all the APIs and events that are available.

On the left panel, you should be able to see the metadata APIs and the asset API that are currently available and also the events. They'll probably x zoom in and then Yeah. So we'll look at a one or two a a APIs here. Like to see show you how we can try these APIs. And this will also be shown in the demo used in the demo as well.

So let's start with the guest get asset metadata. As you can see, you you can learn more about the API here, what are the required request parameters, and the expected responses here. On the right panel, you can see the request samples. And also the response samples. So let's start with clicking on the try it here.

Actually, let me switch to this tab. I have some values prepopulated. Yeah. Okay. So first of all, you can enter the AM environment information here.

In the bucket so that your target server is populated. And then for the better token, You can use the access token from your, project in Adobe developer console. Let me show you that quickly. Or maybe this is the one. I think.

Yeah. So this is the, access token that you can use and the x API key will be the client ID. So you can enter asset ID in this format. And this you are in a ID, a m, followed by the ID. So that will be the JCRU ID.

You can also get this value from the UI in asset properties. So this is the ID that I'm using. And then if non match is an optional header, which takes the value of an e tag. And e tag is nothing but a current representation of the target resource. Or asset in this case.

I can talk more about this when I when we, try the patch metadata. And then since this is an experimental API, we have to select this value and then let's do a send. Okay. So this is the response. You can see the asset ID, the asset metadata.

And followed by the repository metadata. So in the response headers, you can observe that an attack value is sent, which represents the current, representation of this, asset. So let's go to the patch. And update the asset metadata. So this target server is the same and then We'll use the same better token and next API key.

So for updating asset metadata, You can opt you can pass one or more, patch operations that are available here. You can either add, a property or you can remove it. You can replace copy and move properties and then also test a property if it has a certain value or not. So Let me go here. So for simplicity's sake, I'm just adding a new property here.

Let me change this to another property. And then we'll use the same as it again. And here, if match is a required header, that takes an e tag value So let's, make sure we pass the latest etag value, and we can get that value from either get metadata or ahead metadata. Let me copy this from here. If we don't pass in the latest etag value, then we will get a four twelve, precondition failed error.

So it starts with a four a. Okay. So that's the correct one. And then let's do a reset. Okay.

So the patch is successful and an etag values again returned. Which reflects the current state of the asset now. And you can also see in the response that the property that we added it should be added to the asset metadata here. Yeah. So this was the one that we just added.

So this is how you can play around with the APIs and provide us any feedback. Let me let me get started with creating a project in Adobe developer console. So the prerequisites for this demo are, you need to have access to AM as a cloud service environment with admin access and then also access to Adobe developer console and run time. And also, assuming that you have Adobe I OCL setup. Here, I will start creating a new project from a template.

I use the app binder template. So using the builder template, I'll have some boiler plate code already for creating custom run time actions. So let's so we have this and we'll use the product workspace. Next, I'll, go and initialize this, app that we just created using a IO app in it. This is to set up the project on my local so that I can update the runtime action with the custom logic that we want and then deploy the runtime action as well.

So let's select the org. And this was the project that I just created. So I'm going to select it. And I'll look for all the templates that are available. Okay.

So let me select yeah. The generator apps EX shell. I'm going to use this extensibility template so that I get, a generic action that I could use Here, which Adobe IO app features you want to enable for this project So I'll select actions. I want to deploy a runtime action. And then select type of actions to generate I will go with the generic here.

And then the type of UI or we want to add to your project I will use, pure HTML JS. And then what would you like to name this action? I'll just go with the default options here. So this template is actually creating two runtime actions. One is to access an external API that we'll be using.

Another one is to create messages in cloud events, format, and publish to IO events. Okay. So this project is being initialized for workspace stage. Now I'll go and open this project in my ID. I'd like to show a few files here that we will be updating soon.

So if you look at the actions folder, so these are the two run time actions that got created. And I'll be updating this index dot j s. To add my custom logic. So here is where we will, reach out to PIM System to get the project, product information and then use the asset APIs to update asset metadata. And then there are two other files that I'm interested.

The dot env file where, we'll be adding client ID client secret, and scopes. So these properties will be needed to generate the access token. And there is also app config Yamil, where I'll be adding, these input parameters. Okay. So let's go and see if okay.

This is still being initialized.

Speaker 0: Ramya, if I may shortly interrupt since we're waiting for the update, could I ask you to, click on hide where where it says you're sharing the screen at the bottom.

Speaker 1: Oh, okay.

Speaker 0: Yeah. Perfect. Great. Okay. Thank you.

Speaker 1: Cool. Yeah. Sure. Okay. So the app is initialized.

Now let me switch the workspace. To a production one. Okay. So so this is asking to override some of the files that were initialized for the stage. So I will choose to override it.

Same with the AIU as well. Okay. So let's go ahead and deploy this runtime action so that I'll have an action to select when I'm adding an event. So I'll do AIO app deploy. Okay.

So this will deploy a runtime action. While this is getting deployed, let's go and add an API to this project. So I'm in the production workspace, and you can click on add service here. To select an API. Here, let's filter by the experience cloud.

And you should see this AMS cloud service APIs. So please note this card is available to only those users who are registered in the pre release program. And, also, this will be replaced by an asset specific card once we are generally available. Towards end of this year. So let's select these APIs.

And let's add a credential or what server to server. Here, you can select a product profile, to gain access to our AM environment. So I'll scroll here to see the one that we need to use. Okay. So this is the one that I want to use.

Okay. So the API should be added along with the o auth server to server credentials as well. So I'll quickly switch gears and I need to do a step here in cloud manager UI. So I need to add this client ID I need to allow list the client ID on AM. To do that, let's go here.

Let's on do update the on the cloud manager UI. Select this environment and click on the configuration tab. And we can update it here. So we need to add this Adobe provided client ID. And update this value with the client ID from our Adobe developer console project.

The o auth credentials that we just created. And let's save it. So I did this here because this will take some time to restart the AM environment. Okay. So We can go and add an event now.

So to add an event to the project, again, you can click on add service here and select event. Here, you can select AM assets. That is our event provider. And then choose the AM instance from which you want to receive notifications. So this is the AM environment that I want to use.

And here, you can choose the event that you'd like to receive notifications about. So I'll choose the asset processing completed. And let's select the for server to server credentials that was already added. And I'm going to name this as asset processing complete. You can add more than one event to your project.

So naming it appropriately would be better. Here, you can choose how you would like to receive events. So by default, you'll have journaling API enabled once the event registration is completed. So journaling is nothing but, a pull based mechanism to retrieve events. And from your custom application, you can you can retrieve one or more blocks of events using the journaling API endpoint.

And there are three other optional ways to receive events as well. You can register a webhook here by specifying the webhook URL. And specifying how you'd like to receive the events. And then you can also select a runtime action to consume the events. This is what we're going to do in the demo.

And then there's a third way to read events to receive events directly from your AWS account by specifying AWS account ID and AWS region. So let's go here and select the run time action that we just deployed. So generic is the one that we would like to use. I'm going to select that and then save configured events. Okay.

So let's go back to our ID here. And let's update these files. So here in the ENV file, I will be updating these properties. So let's add the client ID from our WhatsApp server to server credentials. Since these are secured credentials, I'll be deleting them, deleting them at the end of this demo.

So let's use the client ID. And the client secret, and then the scopes. You can see the call command that is used to generate the access token here. So let's go back and add update the app config yamal. So we add them as inputs here so that we are able to read them in our runtime action.

And let's go back to the runtime action. And I'll use I have an updated one so I'll use this and I can give a quick walk through. Okay. So here in the runtime action, the this main function will be executed by IO runtime. And once an event is received, once once an event is consumed, we'll read the event and we'll make sure the event type is asset processing completed.

And then, we'll use the client ID, client secret, and scopes to generate the access token. And once we, generate the access token, we can we can update the asset metadata. With the product information. So to update the asset metadata, I need to get the latest etag value. So we can either make a get metadata or a head metadata call first to get the etag.

So here I'm doing a get metadata. So in the headers, I'm passing the authorization, all the required parameters. And the x API key, let me get the latest client ID. From here. And then retrieve the etag value from the header, response headers, and then make a patch request.

So let's update the x API key here as well. Yep. And this takes the if match, the etAC value, from the value that is retrieved from the get as admitted data. So to add the metadata, I'm adding two properties here, SKU and category. Here is where you can reach out to your PIN system to retrieve any product information.

And then you can pass these values here. So I'm just hard coding the test SKU and a brand. And then we'll execute this call. So this is what we have for our custom run time action. Now let's go and deploy this.

So I will do AIO app run. So that this runtime action is deployed. And I can also see logs here locally. If there are any issues, we should be able to debug. Okay.

So let's go back to our Adobe developer console. So here are a few things that I would like to show. If you go to the run time here on the left, you should be able to see the user defined that the runtime actions that we deployed. And you can also notice the versions that we have here. And then for an event, If you go to the event, you should be able to edit the event registration by clicking on the top right.

And you should be able to edit anything if needed. Like, you can update the event itself and you can update the consumers. So so far what we have done, in the demo is that we have created a project in Adobe developer console. We have initialized the app on our local, using AIO app in it. And then we have added an API to this project and also award server to server credentials.

We went to cloud manager UI and by, a love listed the client ID, on AM, by adding Adobe provided client ID there. And then we also added an event selecting the event provider and the event and also event consumer. We have also updated our runtime action and we have deployed. So once this is deployed, okay, I see this deployed and maybe we can quickly go and check. The version should be incremented.

Yeah. So it's changed to zero dot zero dot two. And let's also check AM if it's up and running. Okay. I see this up and running.

Now we should be able to upload an asset in AM. And once the processing is completed, an event should be generated and sent to IO events. And it should be consumed by our runtime action. And and the product metadata should be updated for that asset in AEM. So let's go here and let me upload an asset.

Speaker 2: Okay. So

Speaker 1: it takes a couple of seconds to process this, create transitions and the metadata is extracted. So once this processing is completed, we can go to our, Adobe developer project and check the event. Let's go back here. So in the event, you should be able to browse the events, that are consumed. So if you go to if you select the event, you should be able to see this debug tracing where you'll see the event coming here.

And then also there is an event browser where you can see, you can browse events with the journaling API. Let's let's see if this is done. Okay. So the processing is completed. Let me go back and click on this refresh list.

Okay. Awesome. So we have the event here. That means it is consumed, by runtime action as well. So if we expand this, you can see the payload and to just verify that this was the event, asset that we just uploaded.

So in your runtime action, you can read any of these properties that are coming from the event. So we have used the asset ID and the repository ID. So let's go back to AM to see the asset metadata updated. So I've updated the default, metadata schema here. To add the properties SKU and category.

So these are the values that we updated on this asset. Using our APIs from the runtime action. So that that wraps up my presentation. Let me, like the demo. Let me go back.

And let's see how we can get started to use this asset APIs and events. Asset APIs for AM as a cloud service are experimental. They're available to pre release, registered users in the pre release mode. Please reach out at a m dash APIs at adobe dot com to get access to these APIs and provide any feedback. The asset cloud native IO events are generally available.

Please note while the previous AMEventing solution is still supported for on premise and AMS, the new AM eventing is by design initiated for AM as a cloud service only. And the list of available event type for, AMCS is being expanded on a rolling basis. If you're missing any event types, you need. Please contact the AMEventing team at a m dash events at adobe dot com. I've also included links to the new asset APIs and events documentation along with the tutorial on assets and the payment integration that we just saw, which uses our new APIs and events.

Let me give a quick recap of what we have learned in addition. First, we have looked at the challenges with the old APIs and events and the solutions that we are offering, for AM assets. Then we looked at few use cases and saw a demo on how we can implement out of process extensions using this new integration architecture. Lastly, we learned how to get started using the new asset APIs and events. Yep.

That wraps up my presentation. We'll proceed with the Q and A session now. Feel free to ask any questions you might have.

Speaker 2: Romeo, we had a couple of questions come in, and I thought it might be good for you. Let's see. The first one was, if customers can fetch and update custom metadata with these APIs.

Speaker 1: Can you come again?

Speaker 2: The question is if customers can fetch and update custom metadata with these new APIs.

Speaker 1: Yes. They should be able to.

Speaker 2: And there was a a a question somewhat related which is what is the difference between these new APIs and the assets HTTP APIs that, for use cases like retrieving and updating asset metadata?

Speaker 1: So is it the differences between, the overall APIs in general or just the specific asset asset metadata related ones?

Speaker 2: The question was around use cases like updating asset metadata.

Speaker 1: Okay. So there should be definitely, like, there are some missing APIs, in the HTP APIs that I know. And, with with the asset open APIs, we are we are, sending asset metadata. That includes your custom metadata and, any processed information, like the tags, the smart tag, as well. And and you sent the repository metadata, as well.

So I would say the the metadata that is being structured is different, when compared to the h old HTTP APIs. And there's a there's an opportunity now that you can patch, one or more properties on asset metadata. Using our APIs?

Speaker 2: And we have a follow-up question. To to your answer, which is, what do you mean by repository metadata?

Speaker 1: So that is something this re this metadata is something that is generated by the repository and that cannot be edited by any user. Like, for example, when an asset is created and updated and last published date and so on. So that is, like, the read only metadata, but asset metadata is something that we can add new properties to.

Speaker 2: Great. Thanks. Christian Wagner asked if, the old APIs will be deprecated and if he has

Speaker 1: So the old APIs, once we have this feature parity, like, once we have all the APIs on the open APIs. They would be deprecated, and we are working towards it. So the the APIs that we have currently are experimental and will be generally, the APIs will be generally available mostly towards end of this year.

Speaker 2: Thank you. Let's see. So next question was asking if we could capture an event, in the event if we can see which processing profiles were used. So if we uploaded an asset, A processing profile set to apply a Lightroom filter, can we capture the event to know which particular Lightroom filter was used?

Speaker 1: So right now in the events, we have certain properties being sent. I'm not sure if a processing profile value is being sent currently, but if you could email your, If you can email your requirement to AM assets, I think, that'll be a good forum to, take it forward and discuss.

Speaker 2: Sonal asks if, to use these new APIs, they need to create a project in the Adobe teleper console?

Speaker 1: Yes. We need to. Yep. So, as I showed that you should be able to add the asset, API's card, once you register in the pre release program, you should be able to see that card and start using the APIs.

Speaker 2: Let's see. Recrush has asked what the use cases are for AM sites but, for this session, Marques, we're gonna just talk about assets. There are sites APIs available for, content fragments at the moment. But that would be outside of the scope of the session. Puneet asks about, the current assets HTTP APIs and if they're going to be deprecated name as a cloud service, but I believe that Rami is already in that question.

George Taylor asks if there's any restrictions on what the app can call. I'm not clear on what you're asking there, George. Maybe if you clarify your question we can answer that for you. Sara Vona asks if they wanna pass custom payload files into actions. So, for example, they have a CSV of metadata.

They wanna upload to AEM, and they wanna create a runtime action to do that. Do you know of a way that they can, use a runtime action to process something like a CSV file?

Speaker 1: Not super sure on that. Maybe, you can also email us at, AM events, and we can take a look at that.

Speaker 2: Oh, I see. George was asking in your runtime action. An example that you gave, you're talking to a PIM system. He's asking can I call any internet based system to get data via the API to add to ADM?

Speaker 1: Yep. That should be possible. Yep.

Speaker 2: I don't know what your question is, Sonal. Stenal says that there's two use cases. Explain one and for the other one is something with Slack, what does it mean? But I don't I don't know what you're asking there.

Speaker 1: Yeah. So, I have shown, like, two use cases, and the first use case was the one that I did a demo. And the second use case, I just wanted to put out the generic use case where events are consumed and, these events are sent as notifications to a Slack channel. So that was just another use case.

Speaker 2: So you could you could send that to to anywhere you can integrate with programmatically. So I think she was just showing kind of the use case of getting notifications out of out of the. George Taylor asks if the new APIs also allow updating renditions and potentially adding additional content or is it limited to the metadata changes

Speaker 1: So the API that we have currently, it's just to update the metadata. But we can look at adding renditions, if that's possible in a in our future iterations.

Speaker 2: Sonal asks, we can send notification of an asset outside of AM also. Are you are you asking if you're you can listen for events of assets outside of AM or if you're sending notifications outside of AM. The use case was to send notifications to some system outside of AEM based on things that happen inside of AEM. But the session is about events that are being raised due to things happening inside of AM. I'm not sure where your question is.

I'm sorry. And then I guess other people have started having conversations via the Q and A pod. I I think we maybe have answered the outstanding questions at this point. Does anybody have additional questions?

Speaker 0: So while we're waiting for additional questions to appear, Thank you very much, Ian, and thank you, Ramya, for your presentation and demo. I'd just like to point out that we, We gather all the feedback and feedback is valuable to us. So I'd like to ask you to, complete the ending call where you can wait this session. And, send us a request for our proposals for others, sessions and webinars. So it's just a one or two minutes Paul.

I posted the link into the general chat. Thank you.

Speaker 2: Sora Vona has asked if there's, through our events, if an asset is published into dynamic media.

Speaker 1: Not right now. So we are working on, like, published events that will be, available soon. But not right now. And

Speaker 2: Andre asks if customers will still have the ability to create and use custom events.

Speaker 1: What this meant by custom events? Sorry. I didn't get that.

Speaker 2: I think he's referring to the fact that with the add on, you can customers can generate whatever custom events they want and and send those events. Mhmm. I I answered this in a previous answer to a question, Andre, which was the, the custom event provider is, being deprecated, but it is not being removed yet. The goal eventually someday would be that we're producing enough events, events for enough topics from, out of the box that you wouldn't need custom events. That that those can answer whatever business cases you know.

But for today, we're not removing support for for that, add on. So you'll still be able to generate custom events for now.

Speaker 1: Yep.

Speaker 2: Are there other questions?

Speaker 0: We're gonna wait another moment and, then slowly end this session if there are no additional questions.

Speaker 2: There were a couple questions that came through, about asset upload. The old create asset, API and how customers should should be uploading assets. Is that something that you could speak to?

Speaker 1: Yeah. So we have, new APIs planned to replace the upload APIs that we have currently, but that is something that is not available in open APIs right now.

Speaker 2: So Nal asks if they could use these asset APIs in an AM project itself.

Speaker 1: So since these are experimental, I'm just thinking, like, we would need to still do a couple of things like adding Okay. So without the Adobe developer console, is it? Yeah. I think so. Yep.

Using the

Speaker 2: They're asking if they could call these APIs from inside of code deployed inside of a. Yeah. And I would I would suggest this and all that, the whole purpose of these APIs is to be able to, customizations outside of ADM. So you wouldn't wanna deploy code inside of ADM that was making calls back to itself via HTTP API. The whole idea is to call from outside of a, you know, FNC APIs.

Sauravana has asked if they can do ingestion with the asset compute microservice with a similar action. And if there's hiccups in volume, like if it can't process more than a gigabyte of assets, I think some of that may be a little out of scope of the presentation here today. Any uploads that you do during using the, supported upload APIs. And now I've posted some links to a previous question here. Will be processed via the asset compute.

Microservice, and there are some limits in terms of what, the asset compute microservice can process. Those those would be documented. But but they're not part of what we're covering in the presentation here. One, Sanchez has asked if there's an API that can be used for searching assets.

Speaker 1: We don't have a search API yet, but that's in our, to do list. Like, we'll be working on the search API very soon.

Speaker 2: In the meantime, Juan, you might wanna take a look at the query builder API for today. We know that it's a bit limited, which is part of why we're looking at adding a new user API. Naha has asked what the recommendation is ingest an asset from inside AM into a, I'm a little confused by the question because if it was already inside AM, I don't know why you'd need to adjust it. I I think maybe you're asking what the recommendation is to ingest assets by using code that's deployed to the AM environment and the recommendations to not do that. It's, part of our, best practices for AM as a cloud service.

I will post again, maybe to the general chat. The, the the two, links that I shared earlier, this first one that I'm pasting here, or developer reference materials for assets as a cloud service and then the second is for a utility called the AM upload that we provide as an SDK to make it easier to do the uploads. But we don't currently support streaming the asset binaries that you're uploading through the AEM JPM. And this architecture we've developed is specifically to avoid that. So we don't recommend the customers do uploads from codes running inside of the AM environment.

Speaker 0: Okay. Thank you, Ian. So we have answered all questions. We're gonna wait one more minute. And if no other questions appear, we'll close the session.

And before you leave, please make sure to, post your feedback in in this, poll. In the ending poll, we have posted in the general chat. Where you can rate the session and, provide suggestions for further, webinars. Thank you.

Speaker 2: So now, as as you said these APIs are experimental for now, which is why the project needs to be created in developer console. But in the future, we can use directly in an AM project.

Speaker 1: In AM project as in not in the developer console.

Speaker 2: No. Yes. So now that we're not using the developer console because this is experimental. We're using the developer console because that is the way that you'll provision access for these APIs. That's that's not a function of it being experimental.

That's the design of the architecture.

Speaker 1: Yeah. You should be, able to like, use the APIs using your repository URL and, use the API endpoints. So that should work as well, not necessarily from your DOBee developer console. If that is what you meant to ask.

Speaker 2: Sara, asks how to read the logs inside the runtime action.

Speaker 1: So, when we deploy this, as I showed, like, to see the logs on my local, I I had to do AIU App run. So that that's for the development purposes. You can you can deploy the action to remote and also see the logs If there are any issues, you can, debug in your local using AIO Appron.

Speaker 2: How how would they see the logs once they deploy the remote action?

Speaker 1: There should be some way to see the logs in the Huddl developer console. I'm not super sure on that. Maybe we can get back to you on this.

Speaker 2: Okay. Yeah. We'll follow-up with you, Sara. So I'll clarify that they're asking if they can get access to the API only from the developer console. So now, if you wanna create a server to server integration and you need to create a technical account to to connect, you would need to use the Adobe developer console to do that.

To access these APIs. David, welcome David has, said that, an app builder you can log forward to New Relic or other providers. If you want to monitor your your logs from the app builder action, Sarvana, you may wanna set up log forwarding in a way like David is suggesting. Alright.

Speaker 0: I think, we have answered all questions. If you still should have a question or that you haven't posted it or you just need to think about it, you can still post it in the contextual, thread post the question, the session, and we can answer this on there. So thank you very much for attending and for your, attention. Also, thanks again to Romeo, Ian and team. We're gonna end this session now.

The recording will be posted by end of the week and the contextual thread first. And then, followed by the AMGEMs archive, which is Adobe dot com slash go slash gems. Thanks, and I hope, you found this session valuable. Have a nice day or evening. Bye bye.

Speaker 1: Yep. Thanks. Bye.


Kautuk Sahni