SAP Community - SAP Business Technology Platform

First SAP Tech Night Melbourne on 13th June 2024

2024-05-12T07:35:46.966000+02:00

Hi SAP Community,

We are moving the SAP Tech night to June as the date concides with SAP Mastering Dates, we are organising a SAP Stammtisch event ( SAP Yarning Circle ) instead please find the details here

sap-stammtisch-melbourne-may-24

The AWS team are happy to host the SAP Melbourne Community Tech night at their Builder Studio, the first of its kind in the souther hemisphere. I am so excited to be able to organise and be part of this event. Please find below what our friends at AWS had to say

AWS welcomes the Melbourne SAP Tech Community to the AWS Builder Studio Melbourne, the first of its kind in the Southern Hemisphere. The AWS Builder Studio encompasses 350 square metres of showroom, collaboration space and workshop in the heart of downtown Melbourne on Collins Street. The centrepiece of the AWS Builder Studio is the Innovation Showroom where you have the opportunity to discover innovation in action with industry aligned demonstrators to spark ideas.

Further details : https://aws.amazon.com/local/australia/melbourne-builder-studio/

Location: AWS Builders Studio, L1, 555 Collins Street, Melbourne (Corner of King St and Collins St)

Date: Thursday 13th June, 5:30pm - 8pm

We will also have an "Innovation Showcase:AWS Builders Studio Tour" which will be organised by our friends at AWS.

Please register your interest with the below link, will help us with the count.

https://community.sap.com/t5/sap-inside-track/first-sap-melbourne-tech-night-june-2024/ev-p/13677153

If you would like to present a one of the two remaining tech nights for 2024 please get intouch with us (sapsitmelbourne@gmail.com)

Fun fact, did you know that the Global Running Day is on 5th June. We might be doing something on that day, details to follow soon.

Cheers,

Sai

Renewal of custom domain certificate using the Custom Domain Manager app

2024-05-13T08:00:00.024000+02:00

Introduction

As I used certbot to sign my custom domain certificate it is only valid for 3 months and I need to renew it.

Last time, I used the CF CLI plugin for custom domains because CLI is just cool but also because I didn’t know if the custom domain manager application is free or costs extra. Nevertheless, I wanted to use the custom domain manager application for the renewal of the certificate to compare it with the CLI.

Preparation: Activate the custom domain manager application

First, make sure you have the entitlements in your subaccount for this:

Now, you should be able to subscribe to the Custom Domain Service with plan standard in your subaccount:

Once subscribed, your subaccount contains new roles. Assign the Custom Domain Administrator role to your user:

With the authorizations you can start the application. Go to "instances and subscriptions" to find the Custom Domain Manager in the list of subscriptions. Select the line and you’ll see the button “Go to Application”. This button will bring you to Custom Domain Manager application:

Renew certificate – Try 1

My expectation was that I would be able to simply renew the certificate in the earlier created private key. Unfortunately, I didn’t find any button in the screen of the private key to do so, no option to request a new CSR, no update certificate,... .

Renew certificate – Try 2

This brought me back to the CF CLI where I tried the command to get a new CSR:

This one clearly stated that the CSR is not available anymore.

Renew certificate – Try 3

So I tried to use the previous retrieved CSR again (which I stored on my computer) to send it to certbot for signing:

Once signed, I tried to upload it to the same private key which resulted in the following error.

Renew certificate – Final try

When looking for SAP notes about the previous error message I found the following SAP note:

https://me.sap.com/notes/3233828

This says it is not possible to use the same key for updating the certificate with a reference to the documentation: https://help.sap.com/docs/custom-domain/custom-domain-service/update-certificate

This means we need to create a new key every time we renew the certificate and delete the previous one afterwards:

With this new information, I went back to the “Custom Domain Service Manager” application:

In the app I navigate to the tab “Server Certificates” followed by “ Create Server Certificate for your Custom Domains”:

This starts a wizard where I provided the following information:

Alias: a name that contains the month and year for the certificate
Key Size: I kept the default “3072”

Select the landscape to apply the custom domain on:

I also used the opportunity to use “*.lemaire.tech” as main domain. This allows me to use wouter.lemaire .tech but also other subdomains for “lemaire.tech” without always to have “wouter” in it😊 . So I selected the following two:

All the details for the subject:

Once the wizard is finished I was able to download the CSR:

This opens a dialog with the certificate which you have to copy into a .pem file:

This CSR (.pem) file can be used to sign it with certbot using the following command. The steps are the same as the first time when using CF CLI. The command to sign it with certbot:

certbot certonly --manual --csr ./csr.pem --preferred-challenges dns

During this process I had to apply the following config in the custom domain configuration of google domains:

Once saved it looks like this, it still contains the previous acme record in my config:

This generated again a certificat chain that can be uploaded to BTP in the Custom Domain Manager:

In the Custom Domain Manager app I had to paste the certificate from the file. Certbot provided me 3 files but only the last one is needed:

Validate the certificate and click on next step:

The last step is just for confirmation, just click on Finish:

This will result in two certificates, one that will expire soon and one which is inactive (the one you just created):

Activate the new Certificate

Click on the newly created private key and click on “Activate”:

This opens a new wizard where you need to select the Subject Alternative Names which you would like to activate. I only selected “*.lemaire.tech” because I want to use it for other subdomains but not the “lemaire.tech” domain itself.

I just continued with the default TLS configuration:

Validate the summary and confirm!

Final step, configure the domain in your custom domain manager (I use google domains for this):

Cleanup

Once the new certificate is active, you can delete the previous one. Navigate to the previous certificate and click on delete:

After cleaning up, you should have one left:

Result

I have my personal website running using this domain: https://wouter.lemaire.tech

Next to that, I also used to domain to make an easy to remember url for the BTP Service overview matrix application: https://btp-services.lemaire.tech

My conclusion, the Custom Domain Manager application works great and makes a lot of the steps easier to execute. Nevertheless, using the CF CLI helps to better understand all the steps you need to execute. In the end, the application executes the CF CLI commands through an API with a UI on top of it which makes it more user friendly 😉

Configuration as code (CaC) with destinations.

2024-05-13T12:54:57.123000+02:00

Configuration as code (CaC) with destinations.

Destinations are very handy and powerful mechanism to facilitate access to target systems and devices.

When it comes to SAP BTP destinations, the idea is to manage both subaccount and instance level destinations (and/or their certificates) as shared configuration resources on a provider subaccount level.

That way, the destinations configurations can be stored as versioned assets in a source repository and need to be maintained only once per provider, thus, without incurring application runtime tie-in.

Last but not least, BTP destination service is used as a self-configuration tool.

Configuration as code with SAP BTP destination service

Table of Contents

Configuration as code with SAP BTP destination service.

create shared destination service instance and binding.

Provision bootstrap destinations.

Configure destination resources.

Documentation.

PS.

Bootstrap destinations definitions.

Even, if there is no intrinsic BTP CLI command to assist in creation of destinations from service bindings, this can be achieved quite easily with a bit of jq gimmick by applying service binding credentials to a json payload template, for instance:

{
    "init_data": {
        "subaccount": {
            "destinations": [
                  {
                    "Description": "dest-httpbin",
                    "Type": "HTTP",
                    "clientId": "sb-clone12847c4c89544b4f9234b26ede429f62!b282590|destination-xsappname!b62",
                    "HTML5.DynamicDestination": "true",
                    "HTML5.Timeout": "60000",
                    "Authentication": "OAuth2ClientCredentials",
                    "Name": "dest-httpbin",
                    "tokenServiceURL": "https://<subdomain>.authentication.us10.hana.ondemand.com/oauth/token",
                    "ProxyType": "Internet",
                    "URL": "https://httpbin.org",
                    "tokenServiceURLType": "Dedicated",
                    "clientSecret": "<clientSecret>"
                  },
                  {
                    "Description": "SAP Destination Service APIs",
                    "Type": "HTTP",
                    "clientId": "sb-clone12847c4c89544b4f9234b26ede429f62!b282590|destination-xsappname!b62",
                    "HTML5.DynamicDestination": "true",
                    "HTML5.Timeout": "60000",
                    "Authentication": "OAuth2ClientCredentials",
                    "Name": "destination-service",
                    "tokenServiceURL": "https://<subdomain>.authentication.us10.hana.ondemand.com/oauth/token",
                    "ProxyType": "Internet",
                    "URL": "https://destination-configuration.cfapps.us10.hana.ondemand.com/destination-configuration/v1",
                    "tokenServiceURLType": "Dedicated",
                    "clientSecret": "<clientSecret>"
                  }
            ],
           "certificates": [
           ],

            "existing_certificates_policy": "update",
            "existing_destinations_policy": "update"           
       }
   }
}

Alternatively, one could resort to using SAP Cloud SDK built-in service binding destinations.

The below nodejs code snippet demonstrates how to leverage SAP Cloud SDK with its service binding destinations with the likes of service manager and destinations services.

apiVersion: serverless.kyma-project.io/v1alpha2
kind: Function
metadata:
  name: {{ .Values.services.srv.name }}
  labels:
    {{- include "app.labels" . | nindent 4 }}
    app: {{ .Values.services.srv.name }}
spec:
  runtime: {{ .Values.services.srv.runtime }}
#  runtimeImageOverride: {{ .Values.services.srv.runtimeImageOverride }}
  source:
    inline:
      dependencies: |
        {
          "name": "{{ .Values.services.srv.name }}",
          "version": "0.0.1",
          "dependencies": {
            "axios":"latest"
            ,"debug": "latest"
            ,"@sap/xsenv": "latest"
            ,"@sap-cloud-sdk/http-client": "latest"
            ,"@sap-cloud-sdk/connectivity": "latest"
            ,"@sap-cloud-sdk/resilience": "latest"
            ,"async-retry": "latest"
          }
        }
      source: |
        const debug = require('debug')('{{ .Values.services.srv.name }}:function');
        const NOT_FOUND = 'Not Found';
        const xsenv = require('@sap/xsenv');

        const services = xsenv.getServices({
          sm: { label: 'service-manager', name: 'saas-sm' }
          ,
          dest: { label: 'destination' }

        });
        console.log('saas-sm: ', services.sm);

        const readServices = xsenv.readServices();
        console.log('readServices: ', readServices);

        const httpClient = require('@sap-cloud-sdk/http-client');

        const cloudSdkConnectivity = require('@sap-cloud-sdk/connectivity');
        const { retrieveJwt, decodeJwt, Destination } = require('@sap-cloud-sdk/connectivity');
        const { setGlobalLogLevel, createLogger } = require('@sap-cloud-sdk/util');
        const { retry } = require ('@sap-cloud-sdk/resilience');
        const { resilience } = require ('@sap-cloud-sdk/resilience');
        const ResilienceOptions = {
          retry: 10,
          circuitBreaker: false,
          timeout: 300*1000 // 5 minutes in milliseconds
        };          

        const retryme = require('async-retry');

        setGlobalLogLevel('debug');
        const logger = createLogger('http-logs');

        module.exports = {
          main: async function (event, context) {
            const req = event.extensions.request;

            const message = `Hello World`
              + ` from the Kyma Function ${context['function-name']}`
              + ` running on ${context.runtime}!`
              + ` with the request headers ${JSON.stringify(req.headers,0,2)}`;
            console.log(message);
            
            if (typeof req.path !== undefined) {
              console.log('path: ', JSON.stringify(req.path,0,2))
            }
            if (typeof req.params !== undefined) {
              console.log('params: ', JSON.stringify(req.params,0,2))
            }
            if (typeof req.url !== undefined) {
              console.log('url: ', JSON.stringify(req.url,0,2))
            }
            if (typeof req.authInfo !== undefined) {
              console.log('authInfo: ', JSON.stringify(req.authInfo,0,2))
            }

            const { pathname } = new URL(req.url || '', `https://${req.headers.host}`)
            console.log('pathname: ', pathname)

            const url = require("url");
            var url_parts = url.parse(req.url);
            console.log(url_parts);
            console.log(url_parts.pathname);

            // returns an array with paths
            let path_array = req.url.match('^[^?]*')[0].split('/').slice(1);
            console.log(path_array)

            console.log(req.url.match('^[^?]*')[0])

            if (!path_array?.length) return 'Please use an API verb';  
            const actions = [ 
               { name: 'offerings', verb: 'service_offerings', dest:  'saas-sm', url: '/v1/' },
               { name: 'plans', verb: 'service_plans', dest:  'saas-sm', url: '/v1/'  },
               { name: 'instances', verb: 'service_instances', dest:  'saas-sm', url: '/v1/'  },
               { name: 'bindings', verb: 'service_bindings', dest:  'saas-sm', url: '/v1/'  },
               { name: 'instanceDestinations', verb: 'instanceDestinations', dest:  'faas-dest-x509', url: '/destination-configuration/v1/'  },
               { name: 'subaccountDestinations', verb: 'subaccountDestinations', dest:  'faas-dest-x509' , url: '/destination-configuration/v1/' }
            ];
            
            const action = actions.find( ({ name }) => name === path_array[1] )
            console.log('action found: ', action)

            if (path_array[0] == 'srv' &&  action !== undefined) {

              path_array = req.url.match('^[^?]*')[0].split('/').slice(2);

              console.log('path_array: ', path_array)

              const queryString = req.query;
              console.log('queryString: ', queryString)
              const urlParams = new URLSearchParams(queryString);

              const params = req.params;
              console.log('params: ', params) 

              try {
                  // https://sap.github.io/cloud-sdk/docs/js/features/connectivity/destinations#service-binding-environment-variables
                  const endpoint =  path_array[1] !== undefined ? '/' + path_array[1] : '';
                  console.log(endpoint)
                  let res = await httpClient.executeHttpRequest({ destinationName: action.dest }, {
                      method: 'GET',
                      url: action.url + action.verb + endpoint
                  });
                  return res.data;
              } catch (err) {
                  console.log(err.stack);
                  return err.message;
              }
              
            }            
          }
        }
   scaleConfig:
    maxReplicas: 5
    minReplicas: 3
  resourceConfiguration:
    function:
      profile: S
  env: ## https://kyma-project.io/docs/kyma/latest/05-technical-reference/00-configuration-parameters/svls-02-environment-variables/#node-js-runtime-specific-environment-variables
    - name: FUNC_TIMEOUT ## Specifies the number of seconds in which a runtime must execute the code.
      value: '1800'
    - name: REQ_MB_LIMIT ## payload body size limit in megabytes.
      value: "10"

    - name: DEBUG
      value: '{{ .Values.services.srv.name }}:*'
    - name: SERVICE_BINDING_ROOT
      value: /bindings
    

  secretMounts: 
    - secretName: {{ .Values.services.sm.bindingSecretName }}
      mountPath: "/bindings/saas-sm"
    - secretName: {{ .Values.services.dest.bindingSecretNamex509 }}
      mountPath: "/bindings/faas-dest-x509"

Technovation Summit 2024: Expand your AI and BTP Horizons

2024-05-13T15:21:27.786000+02:00

This week the SAPinsider Technovation Summit will commence its inaugural event, with the topics of Artificial Intelligence (AI) and SAP Business Technology Platform (BTP) the stars of the show. And following on just a few short months from the last SAPinsider EMEA conference, it will be great to see if the buzz and excitement around these two topics is just as palpable in Barcelona as it was in Copenhagen.

Technovation Summit 2024 is a 1.5-day event designed for anyone interested in AI or SAP BTP and offers an agenda rich in informational sessions and learning opportunities for any technology enthusiast seeking to expand their knowledge and understanding of the development, application and best practices in these two hot topics. And in addition to hearing from a wide range of speakers at the event, there will also be ample opportunity to network and dive into deeper technology discussions with technology experts and industry peers.

Barcelona of course is a wonderful city location for an event like this. After spending a long day inside, absorbing all the sessions that one can fit into a day, building your knowledge and expanding your horizons of the potential that AI and BTP has to offer your business, what better place could there be to then relax and reflect on the day by taking the time to visit the beach, enjoy a city walk, or unwind and eat Tapas in one of the many tavernas on Las Ramblas, while marveling at the diverse and unique architecture.

6 of the Best for Barcelona

The trouble with attending any event, is selecting which sessions to see that will prove to be of most value to you, especially when there are so many opportunities to learn new things. My advice is simple, try and plan as much in advance, and create your personal agenda as early as possible, so that when you get to the event you can spend less time planning and more time networking and seeking answers to the burning questions that are most important to you and your business.

So why don’t I help a little and start you off with some suggestions for your agenda. Let’s simply assume that everyone will plan to attend the day-1 and day-2 keynotes, to be delivered by Iver van de Zand (14 May, 9:30am) and Prof. Marek Kowalkiewicz (15 May, 9:30am) who will share their own insights and experiences of AI, and in the case of Iver BTP too, setting the scene and the tone for each day of the summit. But after the keynotes, what next? Here are my personal 6 picks for Barcelona:

Generating the Future: SAP Business AI and the Generative AI Roadmap, 14 May, 10:45am to 11:30am
AI Ethics – A Primer to Guide your Organization on the Opportunities and Risks, 14 May, 11:45am to 12:30pm
How to Automate Document Streams using SAP BTP and Machine Learning, 14 May, 1:30pm to 2:30pm
Case Study: Moving From On-Premises to The Cloud with SAP Integration Suite, 14 May, 3:00pm to 4:00pm
What's on your Mind? Maximize the Potential of SAP BTP & AI, 14 May, 4:15pm to 5:00pm
What's on your Mind? Unveiling the Magic of Digital Transformation, 15 May, 11:45am to 12:30pm

And, if you don’t mind, I’ll take a liberty and add one more to see. This isn’t strictly a session, but it will cover many topics that are BTP and AI related, and this is delivered in the form of a BTP: Technology News Update, which will take place at the SAP booth during the networking break at 10:15 on 14 May. Please head to the booth to hear from our presenter Carles, and then network with the SAP onsite team to ask them any questions that spring to mind. Don’t be afraid to challenge them – they’ll appreciate you spending the time to talk with them!

Of course, these are just a few suggestions, and there are many more sessions available for you to select from the agenda. Why not take a look at the SAPinsider Technovation Summit website and look at the event sessions list, or even better download the SAPinsider2024 event app to your smart device (available on the App Store and Google Play) and to see a full list of available sessions, and to create your own personal agenda.

Continue Your Learning After the Event

While I’m sure you’ll enjoy your experience and learning opportunities in Barcelona, I expect that you’ll also want to continue your own personal learning journey after the event too. In this case why not explore other learning opportunities from SAP. For example, find out how to build software applications, side-by-side extensions, and integrations to and from cloud applications by exploring SAP’s free learning content on SAP BTP. It is made for both integration designers and extension developers from all levels of expertise and will help you stay up to date with the latest SAP BTP innovations. And check out even more role-based learning resources and opportunities to get certified in one place on SAP Learning site.

For those of you travelling to Barcelona this week, I do hope that you find the SAPinsider Technovation Summit to be an informative and stimulating experience. My best wishes for safe travels, and I hope that you enjoy the event!

Chris Grundy

Product Marketing, SAP BTP

Watch the SAP BW Modernization Webinar Series

2024-05-13T15:49:24.460000+02:00

Step into the future with our SAP Business Warehouse Modernization Webinar Series. Designed with the goal of revolutionizing the way you approach your SAP Business Warehouse (SAP BW) with SAP Datasphere, this series provides you with an unparalleled opportunity to learn, grow, and take your SAP BW environment to the next level.

Each session comes packed with valuable information, transformative guidance, and real-life insights from seasoned SAP BW and SAP Datasphere experts. The series includes:

Industry-Expert Guidance: Our sessions are hosted by technical experts from SAP, offering you the unique opportunity to learn from those shaping the future of business data technology.
Practical Tools and Applications: We'll demonstrate the SAP Readiness Check, the SAP Expert Evaluation Tool, and SAP BW Bridge to ensure you have a robust toolbox.
In-Depth Case Studies and Demonstrations: We’ll share how other customers have successfully modernized their SAP BW environment. Each session concludes with thorough demonstrations that you can apply in your practice.

Access the webinar series

The overall length of the seven units is close to 7 hours. We have divided the recordings into several parts of 2 to 20 minutes for ease of use. Find the materials below:

Unit 1: Modernizing SAP Business Warehouse, Explore Your Options

Lesson 1: Exploring Transition Option to SAP Datasphere – part 1 , PDF |part 2 , PDF
Lesson 2: Embedded Analytics in SAP S/4HANA Cloud - video , PDF
Lesson 3: Modernization Customer Stories - video , PDF

Unit 2: Preparation for Modernization – Your Source System

Lesson 1: Preparation for Modernization - video , PDF
Lesson 2: Exploring the Transition from BW7.x and BW4 HANA Systems to BW Bridge Conversion - video , PDF
Lesson 3: System Analysis Tooling - video , PDF
Lesson 4: Additional Resources - video , PDF

Unit 3: Using SAP Tooling for a Smooth Transition

Lesson 1: Exploring Tools for Evaluating SAP BW System Readiness for Transition to SAP Datasphere - video , PDF
Lesson 2: Understanding the Conversion Paths to SAP Datasphere and SAP Datasphere, BW Bridge - video , PDF
Lesson 3: Leveraging SAP Services for Successful Deployment of SAP Datasphere - video , PDF
Lesson 4: Expert Evaluation Report - video
Lesson 5: Assessment Tools by SAP Partners - video , PDF

Unit 4: Sizing Matters for the Cloud

Lesson 1: tools and methods for sizing of SAP Datasphere - video , PDF

Unit 5: Preparation for Modernization: Your target system

Lesson 1: SAP Datasphere, BW Bridge as your target system - video , PDF
Lesson 2: Strategic Directions and Options for Data Warehousing Solutions - video , PDF
Lesson 3: Exploring the Value and Features of SAP Datasphere - video , PDF
Lesson 4: Additional Resources - video , PDF

Unit 6: A Deep Dive on Transition Approaches

Lesson 1: Remote conversion and shell conversion options - video , PDF
Lesson 2: Metadata and Business Data Transfers in SAP Datasphere BW Bridge - video , PDF
Lesson 3: Transition Approaches - Demo - part 1 | part 2
Lesson 4: Additional resources - video , PDF

Unit 7: BW Modernization Series - Working with SAP Business Warehouse Elements in SAP Datasphere

Lesson 1: Best practices for working with SAP Business Warehouse elements in SAP Datasphere - video , PDF

Get Started

We’ve designed the series to offer a comprehensive overview, from the basics of starting your SAP BW modernization journey to successfully implementing the transition.

Don’t miss the opportunity to prepare your operations, strategies, and mindset for the future with the SAP BW Modernization Webinar series. Take the first step towards empowering your business' digital transformation journey with the first lesson.

Syniti RDG streamlines creation and configuration of MDC process templates.

2024-05-14T10:41:20.003000+02:00

Syniti Rapid Data Governance (RDG) is an SAP-endorsed Cloud-Based UI5 application built on the SAP Business Technology Platform (BTP). SAP Master Data Governance is a powerful solution to improve the quality and consistency of information across organizations by consolidating and centrally governing master data. Syniti RDG’s MDC tile streamlines the creation and setup of process templates and the configuration of its process steps.

Master Data Consolidation (MDC) refers to the process of combining and centralizing master data from disparate sources into a single System. This ensures that there is a consistent and accurate version of master data, such as customer, product, or supplier information, across an organization.

In SAP, Process Templates are predefined sets of steps and configurations that standardize the master data consolidation process. The Process Template you choose during a consolidation process specifies whether and in what order certain process steps are executed and what configurations apply for each step.

By utilizing process templates, organizations can accelerate the master data consolidation process and maintain data integrity across different systems and business units within the SAP landscape. Additionally, process templates facilitate compliance with regulatory requirements and supports ongoing data governance efforts by establishing standardized procedures for managing master data consolidation activities.

To create a process template, traditionally a user had to follow the standard guide to setup process templates:

Select New Entries.
Enter a Process Type ID, a corresponding Description, select the Business Object Type, and the Workflow Template WS54500001.
In the Process Goal field, select the goal of a consolidation process.
Decide for the Default Template and the Delete Source indicators.
Save your entries.

Then to configure said process template a user would have to follow the standard guide to setup its process steps.

Mark a process type template and choose Process Template Step
Select New Entries.
Enter a Step Number.
Select a Process Step Type using the input help.
Select a corresponding Adapter using the input help.
Select a corresponding Configuration ID.
If you want the process to stop after finalizing this process step set the Check Point indicator.
If you want to assign an Authorization Group to the process step use the entry help to select an authorization group.

Pertinent configurations specific to each step type are identified by the Configuration ID. If a user would like to visualize the details for each configuration or create a new one, they would have to navigate to the MDCIMG t-code and select the activity related to the step type desired to configure.

Then a user would have to navigate the list of configurations and select the config id chosen in the process template and double-click it to visualize its detailed settings.

The Master Data Consolidation (MDC) tile on RDG streamlines this whole process by allowing users to create and delete process templates, process steps and its configurations within a single and intuitive screen and define a specific template that outlines the steps and configurations for executing a master data consolidation process.

STEP 1. On the Main screen click on the MDC Tile.

STEP 2. Click on the plus icon to add a new process template.

STEP 3. Input process template name and description and choose a Business Object Type (BO Type).

STEP 4. Select a process goal and decide for the Default Template and the Delete Source indicators.

Process Goal refer to the specific objectives or outcomes that organizations aim to achieve through the implementation of process templates. Depending on the goal selected the user might need to also select a strategy.

STEP 5. To add a process step click on the Add button, select a step type, input a description and make selections for Adapter, Config ID, Action Control and Authorization Group.

STEP 6. Add extra process steps to meet the business requirement and goal of the consolidation prosses.

STEP 7. If needed, user can create and/or visualize the configurations for steps. To visualize the details of a selected configuration, click on the View Details pencil icon. To create a configuration, select “Custom – Create configuration” from the list of configurations.

NOTE: At the time of publishing this blog, RDG supports configurations for steps of type: Activation, Filter and Remove, Best Record Calculation and Evaluation. More to come in future updates.

Details of a Best Record Calculation configuration:

Details of a Filter and Remove configuration:

Details of an Activation configuration:

STEP 8. Click on save and select a customizing transport from the available list.

Using the MDC Tile users can maintain and create process templates in a streamlined and intuitive manner.

Syniti RDG is a certified SAP BTP solution and is available on SAP App Store.

To know more details about the product, check the blog Partner Add-on Solutions.

Your opinions and feedback are highly appreciated and feel free to post them in comment section.

Please follow and read more interesting blogs on SAP Master Data Governance | SAP | SAP Blogs.

You can also find and post questions about the product here: SAP Master Data Governance Community.

10+ ways to reshape your SAP landscape with SAP BTP - Blog 7 Interview

2024-05-15T09:33:29.565000+02:00

Blog 7: The Role of Automation for Transformation - The background Interview

My colleague Philipp Zaltenbach posted an inspiring blog last week and we had a background interview for more information.

Timothy Kaufmann: Philipp, why are you so enthusiastic about Automation with SAP?

Philipp Zaltenbach:There are especially two aspects that I want to highlight. First is versatility. I really like that automation technologies can be applied to such a broad range of scenarios. We have customers that use our technologies for simple approval workflows. These may differ from one Line-of-Business to the other. On the other hand, we have customers such as Lufthansa Technik who use it for complex automation scenarios that touch a lot of applications, both SAP and Non-SAP. The second point is ease-of-use. Many customers who experience our offering in a hands-on workshop are impressed at how quick they can build something without having had extensive training beforehand.

Timothy Kaufmann: Where do you see the USP for SAP?

Philipp Zaltenbach: In my view there are three points that I would stress. First, we have a unified end-2-end offering that can be applied in a modular fashion. This is really unique, given the range of capabilities overall. Second, we have built a lot of pre-built content, such as integration packages, workflows or RPA bots, that can serve as a starting point and avoid reinventing the wheel. Third, the tight and robust integration into our SAP application landscape, be it an S/4HANA system, or an LoB application such as SuccessFactors.

Timothy Kaufmann: How do you see the role of Automation for Clean Core?

Philipp Zaltenbach: As I have shared in my blog article, our Enterprise Automation offering can play an important role in Clean Core initiatives and related ERP modernization projects. It can help both before the move – to analyze, clean-up and streamline processes – but also after the move, to help with continuous process optimization.

Timothy Kaufmann: How do you see the potential of AI for Automation?

Philipp Zaltenbach: With the advent of GenAI we see a massive opportunity for automation. Many customers still have scenarios that require working with unstructured documents such as PDF files. Here our embedded AI services can provide drastic benefits for automated document extraction and processing. On the other hand, we also strive to make the development process even more accessible and simpler by using GenAI based assistance. Users will then be able to talk to the system in natural language and with that they can create entire process automations from scratch.

Timothy Kaufmann: Where do you see the difference between Workflow and Automation?

Automation is a very large area that covers many topics, for example integration, RPA-tools or workflow engines just to name a few. Hence, workflow can be considered as a sub-topic of automation. So workflow can be part of an overall automation that is made of different building blocks, comprising e.g. workflow elements (such as approval forms and business rules), as well as RPA elements (such as bots for UI automation of an application).

Timothy Kaufmann: When you talk to companies about Automation, where do you see the biggest challenges?

Philipp Zaltenbach: The challenges vary from customer to customer. Some customers struggle with where to start and which use cases to tackle. For that we can offer workshops with SAP Consulting or partners to identify the most promising areas and scenarios. Also customers often look for how to get familiar with our products. Here, we have self-guided, interactive learning journeys (e.g. the one for SAP Build) as well as hands-on workshops as a starting point.

If you want to read all blogs:

Blog 1: The Central Role of Clean Core and AI: 10+ ways to reshape your SAP landscape with SAP Bu... - SAP Community
Blog 2: The Role of BTP as Extension and Innovation Platform: 10+ ways to reshape your SAP landscape with SAP Bu... - SAP Community
Blog 3: How SAP Clean Core Strategy can accelerate your Transformation SAP Clean Core Strategy: The Key to Business Transformation
Blog 4: Mastering the Data Dance: The Potential of Clean Core and AI 10+ ways to reshape your SAP landscape with SAP Bu... - SAP Community
Blog 5: How hybrid Integration upholds the role of Clean Core: 10+ ways to reshape your SAP landscape with SAP Bu... - SAP Community
Blog 6: Clean Core Extensibility 10+ ways to reshape your SAP landscape with SAP Bu... - SAP Community
Blog 7: The Role of Automation for transformation: 10+ ways to reshape your SAP landscape with SAP Bu... - SAP Community

Unlocking the Potential of Business AI: Engineering Best Practices

2024-05-15T11:19:59.068000+02:00

This blog post is part of a series that dives into various aspects of SAP’s approach to generative AI, and its technical underpinnings.

In the previous blog post of this series, we learnt about benchmarking of AI models. In this blog post, we will discuss some engineering best practices in the field of generative AI. We will understand the concepts with concrete examples.

Read the first blog post of the series.

Introduction

At SAP, we're at the forefront of integrating AI into business applications and platforms. While generative AI holds immense potential to unlock unprecedented value, translating this innovative technology into practical business solutions does not come without its challenges. It demands rigorous adherence to requirements of reliability, transparency, and ethics to achieve business value.

The development of generative AI applications stands at the intersection of AI technology and deep business domain knowledge. Engineering challenges in developing generative AI applications differ from traditional software development due to unique data requirements, the need for specialized evaluation metrics, ethical considerations, and iterative development processes inherent to generative AI. It is a meticulous process that evolves through hypothesizing, experimenting, validating results, and iterating with feedback — each step is a cornerstone in delivering business AI. On the other hand, understanding the business domain is crucial for enhancing efficiency, user experience, and overall value for business users.

This blog post centers around the engineering best practices that underpin the development of business AI use cases at SAP. To explain the approach, we take the integration of generative AI within SAP SuccessFactors’ business applications, with AI-assisted compensation discussions functionality as a specific case in point.

Engineering Best Practices for Generative AI

At SAP, teams are developing a wide range of use cases from question answering, text generation, classification, and summarization to code generation and are exploring the potential of emerging paradigms such as agentic workflows Running mission-critical processes for customers, SAP teams follow a common set of engineering best practices to ensure enterprise qualities. These are discussed below.

1. Foundational pillars for best practices

Figure 1 outlines the core pillars of best practices, the specifics of which will be explored in the next section's use case deep dive. For instance, discussions on data quality will involve counterfactual analysis, while performance testing will be examined through prompt and model benchmarking results. Moreover, issues of security and ethics will be addressed through AI ethics reviews.

Figure 1: Overview of key pillars covered by best practices

Let us understand each of these pillars.

Data quality: At the core of relevant, responsible, and reliable business AI, is the high fidelity of insights data produced by SAP’s business applications. Only with input data of high quality, can we expect a relevant output. SAP's data governance and standards ensure that the data applied is of high quality and semantically rich.

Bias assessment: It is imperative to assess and mitigate any potential biases in the data or model predictions. This is to ensure that the application is also “responsible”, which is one of the three “R”s, as explained in this blog post by our CEO, Christian Klein.

Performance and testing: Rigorously evaluating and testing capabilities guarantees that results are accurate and reliable. At the same time, applications should meet performance criteria in their specific domains, and this should be baked in early in the development process to prevent cost arising from afterthought. Another key consideration is the performance metrics, the selection of which is subject to business objectives and data characteristics.

Monitoring and maintenance: Continuous monitoring leads to identifying and addressing any issues that may arise during usage (such as performance degradation), and proactively and continuously improving capabilities based on feedback, as well as user research. To achieve the best business outcome, we leverage up-to-date technology and tools available.

Security and privacy: Security is not by chance, but rather by design. Following SAP’s strict security standards and data privacy policy, we implement strong authentication, authorization, threat modeling, and regular audits to safeguard business processes and data to keep them protected.

Explainability: Our product is designed around the concept of explainability to foster enhanced trust and greater user engagement. Unlike "black box" producing results without explanation, allowing authorized users to view what contributes to these results is beneficial. For example, this can be implemented through relevant logs or visualizing the raw data in an inference call.

Ethics: Our longstanding commitment to AI ethics policy and guidelines ensures that use cases go through rigorous ethics assessment including commitment to human rights, designing for people, striving for bias-free business, transparency, upholding quality, and safety. This is in direction with our purpose of helping the world run better and improving people’s lives.

2. Following a common generative AI architecture

To enable internal teams to follow best practices efficiently, use cases are developed based on a common architecture described in the first blog post of this series. This architecture provides teams with tools and technology components on SAP BTP including the generative AI hub in SAP AI Core, the SAP HANA Cloud vector engine and SAP Joule. Generative AI hub in SAP AI core provides trusted access to Large Language Models (LLMs), business grounding for LLMs, and LLM exploration as explained in detail in our second blog post of this series.

Use Case Deep-dive: SAP SuccessFactors AI-assisted Compensation

In this section we will deep-dive into SAP SuccessFactors AI-assisted compensation functionality to illustrate how best-practices guide business AI use case development at SAP. This includes a thorough evaluation process that incorporates an AI ethics review.

Figure 2: Focus on three pillars - data quality, bias assessment, and performance/testing

We will prioritize three fundamental categories for our deep dive: Data quality, bias assessment, and performance/testing. Within these categories, we will especially focus on quality and fairness, with key topics illustrated in Figure 2. In the following sections, we will explore these perspectives in detail, including solution accuracy, robustness, cost reduction mechanism, and bias mitigation.

1. Use case background

Discussions about compensation between managers and their direct reports are sensitive and require careful consideration. Each compensation discussion can be different and requires collating many data points such as job profile, compensation history, and organizational pay bands, to understand the employee’s compensation profile. Managers must spend time analyzing various data sources and preparing talking points for each employee. SAP SuccessFactors AI-assisted compensation system facilitates an equitable & efficient approach for managers to get insights into an employee’s compensation. Managers are thus able to have sensitive compensation conversations with easy access to the data insights & talking points personalized for the employee.

LLMs offer enormous potential in this process to be simpler and more efficient. LLMs provide powerful capabilities to automatically extract key points, summarization, and themes from lengthy historical data. They unlock valuable insights on this data, enabling business users, in this case managers, to take the right business decisions efficiently.

However, as mentioned earlier, using LLMs to analyze compensation data presents its challenges. While LLMs are trained on vast amounts of data and can generate human-like text, they struggle with contextual understanding and thus may result in content that is factually incorrect or misleading. Specifically, lacking a comprehensive understanding of the compensation context makes it hard for them to capture pay bands specific to the company, country, or industry. They are not adept at complex mathematical calculations, leading to errors in reporting increments and thus unreliable quantitative metrics. Additionally, SAP SuccessFactors harnesses extensive tabular data. Unlike text and code, which are one-dimensional, tabular data are two-dimensional. LLM’s restricted ability to comprehend two-dimensional tabular data amplifies the overall complexity. Furthermore, achieving impartiality poses a significant challenge, as biases can be intrinsically embedded in model training or user input, presenting a major ethical concern.

Following best practices, we implemented an LLM-based method for employee compensation review by combining tabular data pre-processing and advanced LLM prompt techniques. Table serialization is employed to reduce token count and make data more understandable for LLM. We extensively evaluate accuracy, robustness, and bias to ensure the solution delivered is relevant and responsible. See figure 3 for an example of AI-assisted compensation insights. Also see one minute demo in this video.

Figure 3: Illustration of AI-assisted compensation insights

2. Boosting relevance with advanced prompting and model selection

Accuracy of the AI predictions is key in providing value to our business users. Across use cases, teams are applying an array of prompt engineering and fine-tuning best practices to infuse domain knowledge and customer specific information. The approach is tailored to ensure that each use case meets business requirements and achieves the desired solution quality. For example, as an advanced prompt engineering technique, chain of thought (CoT) prompting facilitates the generation of more controlled, accurate, and relevant outputs through a step-by-step guidance process. Another example is an agentic strategy like ReAct, which empowers LLMs to leverage tools to improve accuracy.

We want to illustrate how best practices for advanced prompting techniques with long and short instruction contexts boost the accuracy of the SAP SuccessFactors AI-assisted compensation.

To create compensation insights, the context that provides instruction and grounding data about the employee is very important. For the compensation analysis processing to perform accurate arithmetic operations, the prompt instructions must be specific and well aligned with the pertinent contextual data.

Figure 4 compares the quantity accuracy of CoT prompts with long and short instruction contexts and a combination of CoT and ReAct prompts. To preserve the prompt-specific response from the LLM, we manually checked the quantity accuracy. The results show that all three prompting techniques achieved high accuracy scores for quantity extraction. The short context CoT prompt achieved the best arithmetic calculation accuracy. This demonstrates that employing advanced prompting techniques effectively yields high accuracies for both number extraction and arithmetic calculation.

Figure 4: Boosting performance by leveraging domain knowledge through advanced prompting techniques

Once the prompt version has been optimized, we choose the most suitable model from a variety of SAP-built and partner models. For example, for our use case we carry out a range of experiments to benchmark models. Continuing with the short context CoT prompt, we conduct additional testing on LLM’s capability to categorize employees by certain categories such as “underpaid”, “overpaid” and “fair paid”, based on their compensation history data (Figure 5). Among five LLMs shown below, GPT-4 significantly outperforms the other models, achieving higher accuracy across all three categories.

A combination of the techniques above supports an LLM-assisted process, well specialized and accurate in examining employee compensation data. This approach may be used in other scenarios too.

Figure 5: Comparison of the ability to classify “underpaid”, “overpaid” and “fair paid” from the employee compensation data

3. Scenario-specific testing for reliable and robust results

The data in customer systems can be diverse, influenced by configuration and employee tenure. It is crucial that the generated insights are pertinent to the given context. This necessitates a regimen of scenario-specific, good coverage testing to ensure prompt is designed for robustness and adaptability.

In the context of the AI-assisted compensation, we follow this best practice and evaluate the LLM’s responses across a range of scenario-specific data inputs, focusing on a variety of scenarios, such as low or high variance in compensation trend, new and long-standing employees, and decreasing compensation ratio as an extreme case. The responses are then subject to human evaluation. A sample of the key findings are shown in Table 1. It can be seen that the prompt performs well across the tested scenarios, achieving high scores overall, although it scores slightly lower in the scenario involving very long compensation history.

Table 1: LLM result quality from various input data scenarios

4. Optimizing and serializing input data for increased relevance and speed

Further to scenario-specific testing, infusing business data into AI use cases is a key component for relevant results. For enterprise use cases this data often comes in tabular form and additional semantic context as provided by SAP’s business applications. This needs to be optimized too.

We begin by ensuring that the context data provided to generate insights is comprehensive to represent the employee’s tenure and compensation progression. Hence optimizing the token footprint of our input is a necessary step to optimize speed. Simultaneously, another goal is to enhance accuracy through structuring the tabular data input in a manner that maximizes the level of comprehension by LLMs.

Table 2 shows a mock data set, representing salary progression of an employee. Like many other applications designed specifically for SAP SuccessFactors, the data for employee information is stored as a tabular format (structured data). However, LLMs are naturally not good at understanding tabular data when incorporated into their prompts. This is because the connection between column headers and corresponding cell values breaks down when read sequentially. For instance, if we pass “2021” from the second row of Table 1 into the LLM, it will not recognize that value “2021” pertains to the column “Year”.

Table 2. An example of the mock tabular data, used for employee compensation review

To enhance the comprehensibility of tabular data for LLMs, we use a text template to serialize it, before passing it to the prompt. The serialization adheres to predefined templates. For example, a simple template can follow the format “The {column_name} is {cell_value}.”. Our tests demonstrate that the proposed serialization method successfully enables the LLM to understand the relations within the tabular data while maintaining a reduced token size leading to faster and more accurate results (approximately 25% fewer tokens compared to the original JSON format).

5. Understanding and mitigating inherent bias with prompt-centric debiasing

LLMs are prone to producing biased completions due to the imbalanced dataset in the training process. Preventing the propagation of bias in generative AI applications presents unique challenges due to their content-generating nature, such as the compensation tool generating talking points. However, we have best practices in place to identify and mitigate bias by applying techniques such as specific prompt engineering or fine-tuning.

To illustrate this in the context of our use case, we examine potential unintended biases by simulating the recommended salary adjustments across different gender groups. This is achieved by alternating between male and female names in the input parameters to represent the respective gender groups, which are then used to invoke LLM API calls. Note that the salary adjustment is not included in the end results presented to users; it is used exclusively for calculating the quantity for internal assessment purposes.

The outcomes of these calls are subsequently analyzed for statistical assessment.

Figure 6: Comparison for scenarios distinguished by gender in input and prompting style

Figure 6 illustrates the evaluation flow for different scenarios based on gender in the input data and various prompting styles. Specifically, we adopt and assess the prompting thinking style via additional instructions to explicitly instruct the model to remain unbiased.

In Figure 7, we compare the distributions of results obtained before and after the use of unbiased style of prompting and gender pronoun removal. It is found that the use of proper prompting leads to a reduction in the bias, where male & female cases receive similar result distributions with tighter bounds. When gender was directly included in the prompt, those identified as non-binary were generally favored by the LLM.

Figure 7: Gender-based group result distributions: before and after (vertical bars represent ranges and dots represent outliers)

The effect of bias reduction is illustrated in Figure 8. We deduce the bias from the discrepancies observed between the two gender groups. More specifically, we calculate the discrepancy between distributions of gender-based results by measuring the difference in their mean values on a standardized scale. In this figure, for instance, employing a basic prompt will lead to a difference of 0.162 between gender groups with GPT-4. However, this difference can be minimized to a much smaller one of 0.049 using the final prompt.

Figure 8: Effect of bias reduction based on discrepancy of gender group mean values

Based on these evaluation of bias mitigation measures, we actively adjustment our approach to reduce bias in production implementation. This includes removing gender information from the prompt context data and adopting unbiased prompting style.

6. Ensuring reliable and responsible AI through ethic review process

In generative AI, ethical considerations are crucial due to its potential usage for completions, summarization, and classification use cases. Ensuring fairness, transparency, and accountability in the generation process is essential to mitigate biases, uphold privacy rights, and promote responsible business AI applications. At SAP, our AI ethics policy mandates that generative AI applications conform to the three fundamental pillars – “Human Agency & Oversight”, “Addressing Bias & Discrimination” and lastly “Transparency & Explainability”.

Figure 9: Pillars of SAP’s AI ethics policy

SAP SuccessFactors has an AI acknowledgment framework that the business users will acknowledge before using/viewing any AI capability. Additionally, the product standards and risk assessment process mandate that all personally identifiable data is handled appropriately and anonymized. Data access controls are applied by existing role-based permissions, and insight data available is restricted to what the user has access to. Based on application type and the data processed, AI use cases are internally categorized by risk level and undergo a review by the SAP AI ethics steering committee to address any potential concerns related to bias and data safety. The AI-assisted compensation discussion use case has had thorough reviews with the SAP ethics steering committee. The review process has resulted in a strengthened warning notice and improvements of both the prompt and insights content to reduce bias.

The improvements involve steering clear of presumed performance, avoiding generic statements, and creating actionable, bulleted points. Following our best practices, users can view all the data sources that are used to generate insights, ensuring explainability and transparency. This process is described in detail as part of SAP AI ethics handbook.

At the same time, we remain compliant with the European Union AI Act on artificial intelligence, which lists manipulation of cognitive behavior, social scoring, biometric identification people, and their categorization based on it, as “unacceptable risks”. Furthermore, there are well defined transparency requirements towards general purpose AI systems, to be considered. Our solutions, including the AI-assisted compensation review, passes these tests, thanks to the above-mentioned stringent AI ethics review.

Conclusion

At SAP, our engineering best practices are tailored to develop ethical, resilient, and scalable generative AI applications. This synergy enables us to unlock the full potential of generative AI within our business applications and platform to enhance efficiency and productivity for our customers.

In this blog post, we illustrated this by exploring the critical intersection of SAP SuccessFactors business domain knowledge and generative AI expertise. We shared examples of engineering best practices applied during the development of AI-assisted compensation discussion scenario. We detailed the best practices by presenting their quantitative effectiveness from various perspectives, including relevance, robustness, reliability, and bias. Additionally, we outlined the AI ethics review that this use case has been subjected to.

Co-authored by Dr. Shu Zhen, Gayatri Gopalakrishnan, Dr. Jan Dumke, and Agarwal, Akhil

Syniti RDG provides an effortless way to create Data Model extension.

2024-05-16T09:08:22.041000+02:00

In SAP Master Data Governance data can be stored in a staging or active area. Extending the data model with custom attributes or tables involves changes to the data structures in both the active and staging areas and defining a mapping between these data structures.

Traditionally, a user must perform the following steps to assign to do this configuration in SAP MDG System.

Extending active area data model
Extending staging area data model
Generating MDG tables
Defining mapping from Staging to Active area
Defining mapping from Active to Staging area

RDG provides the solution to extend SMT Mapping with an intuitive, user-friendly, and graphical interface.

After a custom attribute is created and activated in either Business Partner or Material data models, an entity table for SMT mapping will be shown if applicable. (SMT mapping is not relevant for attributes created under all entities).

After custom attribute is created and activation is complete mapping table will be shown.
Complete the mapping table by selecting a mapping step and structure to extend for each row. Source and Target will automatically populate. Click

at the end of each row.
Click Done. Processing may take some time to complete. Click Refresh when ready and receive success messages. If running the application using a cloud platform, additional notifications will be given to help you track the process.
Extension, transformation and mapping are created correctly

Syniti RDG is a certified SAP BTP solution on the SAP App Store.

To know more details about the product, check the blog Partner Add-on Solutions.

Your opinions and feedback are highly appreciated, and feel free to post them in the comment section.

Please follow and read more interesting blogs on SAP Master Data Governance | SAP | SAP Blogs

You can also find and post questions about the product here: SAP Master Data Governance Community

SAP BTP Trial Account Creation and Enabling Integration Suite service(SAP CPI)

2024-05-16T09:35:26.608000+02:00

Create an SAP Account from SAP.com
It Creates the SAP Universal ID
Fill in the Required Fields and Click on Submit.

2. After Clicking on the Submit button, SAP will send an email to finalize your SAP account.

3. Open Your Mail and Click to activate your account

4. Now We have to create the SAP BTP Trial Account, go to account.hana.ondemand.com and click on sign in, give your email and password, and click on sign in.

5. After logging into the BTP Cockpit, Click on Trial Home.

6. Choose the region you want and click on Create Account

7. After clicking on Create Account, it creates a Global account and subaccount for you, then click on Continue.

8. Click on Go To Your Trial Account.

9. Click on Subaccount.

10. Click on Instances and Subscriptions

11. Here we can see the services we subscribed to.

To access the Integration Suite, first, we must Subscribe to it.

12. To Subscribe to the Integration Suite, click on Service Marketplace and search for Integration Suite.

13. Click on Integration Suite and click on Create.

14. Click on create.

15. To check Whether the Integration Suite is created or not click on View Subscription.

16. Now we can see the Integration suite in subscriptions.

Click on Integration Suite, it will open the Integration Suite.

17. It will Show you the Authorization error because to access the Integration Suite we have to assign an Integration_Provisioner Role for the User.

18. To assign an Integration_Provisioner Role, Go back to the BTP Cockpit click on Users, and select the User.

19. After Selecting the User click on Assign Role Collection.

20. Search for the Integration_Provisioner Role and click on Assign Role Collection.

21. After Assigning Role, Click on Instances and Subscriptions and then Click on Integration Suite.

22. Click on Add Capabilities.

Note: - Sometimes it will not show the add capabilities option, it will take time to resolve this Refresh the page or try sign-out and Sign in again.

23. After clicking on Add Capabilities, it will show you the list of Capabilities,

Select the capabilities that you need and click on next.

24. In capabilities if you select Manage APIs then this step will appear, select the two checkboxes and click on next.

25. Click on Activate.

26. To activate Capabilities of Integration Suite it will take some time.

27. After the activation click on ok.

28. To create and monitor the Iflow we need to assign some roles related to Process Integration.
Go back to BTP Cockpit->User->Assign the below Roles

29. Now open the Integration Suite from BTP cockpit->Instances and subscriptions.

Now You can create, edit, and monitor the Iflows.

How to use the OData-API for exchanging Messages from Logs and the Datastore in Integration Suite

2024-05-16T09:36:10.757000+02:00

In this blog I will show the basic steps and components to access the MessageProcessingLog and the attached messages, wether they are stored in the log itself, in the MessageStore or in the DataStore.

Later in further blogs I will go into details and show some specific implementations and will compare the different types of message-stores. So please be patient and check back for further information.

The starting point is in the SAP Business Accelerator Hub. There is an API package SAP Cloud Integration which offers some OData APIs in Version 2. We are focussing on the Message Processing Logs and download the definition of, what is called here a vdm - virtual data model. I don't want to go deeper in the edmx, only so far, if you search on your fav. search-engine you may get the following statement:

edmx file is an XML file that defines an Entity Data Model (EDM), describes the target database schema, and defines the mapping between the EDM and the database.

On the Business Accelerator Hub you can find tons of documentation about how to use the source code generator in maven, on how to build up (in this case) java-classes, test the API online, with a sandbox or with your own tenant and even code-snippets in many different languages can be downloaded.

In our scenario we build a client in the Netweaver Development Studio. Then maven-support is initially not part of it but can be added. Search for the keyword M2E. A good starting point on how to generate the client classes (vdm - virtual data model) and how to generate a project from a Maven archetype is on sap.github.io .

The overall framework for the implementation here is an OnPremise fat-client, but everything can run deployed on a BTP tenant, only the GUI frontend needs to be changed.

What you get when generating the sources for your client is the following helper-packages and classes and a MessageProcessingLogsService:

There are several steps to consider for enhancing your pom-file: Dependencies and plugins. E.g. here: SAP Cloud Application Programming Model: Deep Insert (5) Consume Remote Service with SAP Cloud SDK

The starting point here is the method getAllMessageProcessingLogs()

Depending on wether the code runs on your local laptop or in the cloud, you have to create a destination first:

import com.sap.cloud.sdk.cloudplatform.connectivity.AuthenticationType;
import com.sap.cloud.sdk.cloudplatform.connectivity.DefaultHttpDestination;
import com.sap.cloud.sdk.cloudplatform.connectivity.HttpDestination;
import com.sap.cloud.sdk.cloudplatform.security.BasicCredentials;

(...)
public DefaultHttpDestination getDestination() throws IllegalArgumentException	{
	if (destination == null)	{
		if (this instanceof BasicAuthentication)	{
			destination = DefaultHttpDestination.builder(tenant.getURL())
				.authenticationType(AuthenticationType.BASIC_AUTHENTICATION)
	   	    	.basicCredentials(new BasicCredentials(((BasicAuthentication)this).getUser(), ((BasicAuthentication)this).getPassword()))
	   	    	.keyStore(keystore)
	   	    	.build();
		}
	}
	return destination;
}

(On your tenant you can use the DestinationService)

With the destination described above we can request all packages and artifacts. As for now the request is sent by getAllIntegrationRuntimeArtifacts(). This includes iFlows but also Rest-APIs and more.

Unfortunately

runtime-artifacts do not point to any package
designtime-artifacts are called from a package-perspective but do not include some types like Rest-APIs.

(Status on 2024-05-24 is a response of HTTP 501 - not yet implemented. the dev is seems still working on putting everything in place)

Hence we have a gap of links between packages and artifacts, in case they are not iFlows (e.g. Rest-Api). The following code puts "everything" together as complete as possible and attaches the artifacts without a link to a package into a virtual package named "<unknown>"

//create Hashtable for storing our version of packages
designPackages = new Hashtable<String, DesignPackage>();

if (authentication != null)	{
	//get url
	String tenantURL = authentication.getTenant().getRuntimeURL();
	
	//create destination
	DefaultHttpDestination destination = authentication.getDestination();
	
	//create the services generated in the vdm
	IntegrationContentService iCS = new DefaultIntegrationContentService().withServicePath("/api/v1/");
	
	//create Hashtable for storing our version of runtime artifacts
	Hashtable<String, IntegrationRuntimeArtifact> ira_table = new Hashtable<String, IntegrationRuntimeArtifact>();
	
	//retrieve all packages, execute the network-request
	try {
		final List<IntegrationPackage> ip = iCS.getAllIntegrationPackages()
				.executeRequest(destination);
		
		//retrieve all runtime artifacts
		final List<IntegrationRuntimeArtifact> ira = iCS.getAllIntegrationRuntimeArtifacts()
				.executeRequest(destination);
		
		//and put them in the table
		for (IntegrationRuntimeArtifact ira_iter : ira)
			ira_table.put(ira_iter.getId(), ira_iter);
		
		//iterate over all packages
		for (IntegrationPackage ip_iter : ip) {
			
			//store it in our Hashtable
			DesignPackage dp = new DesignPackage(ip_iter);
			designPackages.put(dp.getName(), dp);
			
			//get artifacts for this package
			final List<IntegrationDesigntimeArtifact> ida = ip_iter.getIntegrationDesigntimeArtifactsOrFetch();
			
			//set artifacts as child to the package
			for (IntegrationDesigntimeArtifact ida_iter : ida) {
				String url = tenantURL + "/http/" + ida_iter.getId();
				Artifact a = new Artifact(ida_iter, url);
				dp.addArtifact(a);

				//remove from the list of runtime artifacts
				ira_table.remove(a.getId());
			}
		}
		
		//add remaining artifacts not linked to any package
		if (ira_table.size() > 0)	{
			
			//default package
			IntegrationPackage integrationPackage = new IntegrationPackage();
			integrationPackage.setName("<unknown>");
			defaultDesignPackage = new DesignPackage(integrationPackage);
			designPackages.put(defaultDesignPackage.getName(), defaultDesignPackage);
			
			Enumeration<String> t = ira_table.keys();
			while (t.hasMoreElements())	{
				String iraId = t.nextElement();
				Artifact a = new Artifact((IntegrationRuntimeArtifact)ira_table.get(iraId), tenantURL + "/http/" + iraId + "/*");
				defaultDesignPackage.addArtifact(a);
			}
		}
	} catch (com.sap.cloud.sdk.datamodel.odata.client.exception.ODataConnectionException e) {
	} catch (ODataException e) {
	} catch (Exception e) {
	}
}

Having all packages and artifacts in place, we can get a (filtered) set of log-entries:

/**
* Returns an ArrayList of LogEntries. 
* The list is based on the filtering.
* <p>
* This methods processing-time depends on the amount of data requested from BTP.
* The status should be set on the GUI for user-information.
* In future releases this method will work in a background-task.
*
*  authentication object relevant for login and serving a destination based on this creds
*  logListFilter the object for filtering the requested logs, i.e. datetime and number of entries
* @return ArrayList of LogEntries. 
*/
public ArrayList<LogEntry> updateMessageProcessingLog(Authentication authentication, LogListFilter logListFilter)	{
	
	ArrayList<LogEntry> logEntries = new ArrayList<LogEntry>();
	
	if (authentication != null)	{
		MessageProcessingLogFluentHelper mPLFH = mPLS.getAllMessageProcessingLogs();
		
		//logs should be filtered always by artifact-id (which is unique)
		if (logListFilter.getArtifact() != null)
			mPLFH = mPLFH.filter(MessageProcessingLog.INTEGRATION_FLOW_NAME.eq(logListFilter.getArtifact().getId()));
		
		//number of results limited by number?
		if (logListFilter.getCountFilterEnabled())	{
			mPLFH = mPLFH
			.skip(logListFilter.getCountFilterFrom() - 1)
			.top(logListFilter.getCountFilterTo());
		}
		
		//filtered by date?
		if (logListFilter.getDateFilterEnabled())	{
			//set start and end, logListFilter returns a @LocalDateTime 
			mPLFH = mPLFH.filter(MessageProcessingLog.LOG_START.gt(logListFilter.getDateTimeFilterStart()));
			mPLFH = mPLFH.filter(MessageProcessingLog.LOG_END.lt(logListFilter.getDateTimeFilterEnd()));
		}
		
		//the result is always ordered ascending by the LogEnd
		mPLFH = mPLFH.orderBy(MessageProcessingLog.LOG_END, Order.ASC);
		final List<MessageProcessingLog> mpl = mPLFH.executeRequest(authentication.getDestination());
		
		for (MessageProcessingLog mpl_iter : mpl)	{
			logEntries.add(new LogEntry(mpl_iter));
			
			try	{
				List<MessageStoreEntry> messageStoreEntries = mpl_iter.fetchMessageStoreEntries();
				if (messageStoreEntries != null)
					for (MessageStoreEntry mse : messageStoreEntries)	{
						List<MessageStoreEntryAttachment> mSEAs = mse.fetchAttachments();
						//in future releases <do_something> with the MessageStoreEntries and their attachments
					}
			}
			catch(com.sap.cloud.sdk.datamodel.odata.client.exception.ODataResponseException e)	{
				System.out.println("com.sap.cloud.sdk.datamodel.odata.client.exception.ODataResponseException");
			}
		}
	}
	
	return logEntries;
}

The result, shown as a Java-GUI is as following:

The java-object MessageProcessingLog and corresponding ..Attachment is based on the classes automatically created within the generator-plugin:

With that code we can retrieve the payload on any message starting from object MessageProcessingLog retrieve a MessageProcessingLogAttachment with the following code:

import com.sap.cloud.sdk.datamodel.namespaces.messageprocessinglogs.MessageProcessingLog;
import com.sap.cloud.sdk.datamodel.namespaces.messageprocessinglogs.MessageProcessingLogAttachment;

(...)

//the messageprocessinglog returns a java-List of attachments
List<MessageProcessingLogAttachment> mplAttachments = null;
try {
	mplAttachments = messageProcessingLog.fetchAttachments();
	
	//create a Hashtable which we use to store a local object version of attachment, keys derived from the attachment-name
	attachments = new Hashtable<String, LogAttachment>();
	for (MessageProcessingLogAttachment mpla_iter : mplAttachments) {
		LogAttachment logAttachment = new LogAttachment(mpla_iter);
		//use the name as key and put the attachment in the hashtable
		attachments.put(mpla_iter.getName(), logAttachment);
		
		//this logEntry has an attachment
		hasAttachment = true;
	}
	isPrepared = true;

} catch (Exception e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

Different to the previous approaches, the attachment itself (payload) is not provided as a java-object, but by an InputStream. It will be stored in a String and returned by a getter:

//the constructor gets the 'mpla' when instantiated
public LogAttachment(MessageProcessingLogAttachment mpla)	{
   this.mpla = mpla;
}

//prepare the payload seperate from the getter (for caching purpose)	
public void preparePayload()	{

    InputStream is;
    try {
	is = mpla.fetchMediaStream();
		
	if ( is instanceof ByteArrayInputStream)	{
	  int n;
	  try {
	    n = is.available();
	    byte[] bytes = new byte[n];
	    is.read(bytes, 0, n);
	    payload = new String(bytes, StandardCharsets.UTF_8);
	  } catch (IOException e) {
	    e.printStackTrace();
	  }
        }
    } catch (ODataException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
}
//getter for returning the payload as a String 
//Todo for a future release: what happens if a payload is 'big'? Let's say > 10mb. 
//We don't want to store that in memory in a String!?
public String getPayload()	{
	
    if (payload == null)
      preparePayload();
	
    return payload;
}

Based on the code shown in this blog any app can download, show and also re-send the payload to it's origin:

Stay tuned for further blogs describing details. Don't hesitate to request details in which you are interested.

Best regards Jörg Hopmann

SAP HANA Database Creation from SAP BTP

2024-05-16T09:36:22.580000+02:00

Creation of SAP HANA Database Instance in SAP BTP

Open SAP BTP Cockpit and click on subaccount.

2. Click on Instances and Subscriptions and then click on create button.

3. Select Service as SAP HANA Cloud and Plan as tools.

4. SAP HANA Cloud is now subscribed.

5. Click on Security -> Users and select the user.

6. Click on Assign Role Collection.

7. Assign the following three roles.

8. Click on SAP HANA Cloud Application; it will open in new window.

9. Click on create Instance.

10. Select SAP HANA Cloud, SAP HANA Database and Next Step

11. Provide the instance name and password (next step).

12. Click on Next Step.

13. Click on Next Step.

14. Select Allow all IP addresses, Enable Cloud Connector, and select Allow all IP addresses --> Next Step.

15. Click on Review and Create.

16. Click on Create Instance.

17. Wait until the Instance status turns into Running state and click on Actions three dots.

18. Go to Open in SAP HANA Database Explorer; it will open in new window.

19. Enter the Credentials

Username: DBADMIN

Password: “use the password which was created at Step 11”.

20. Click on SQL Console Icon at the top left.

Now the SAP HANA Database is ready to use.

Build Apps Integration with On-premise systems

2024-05-16T09:39:15.391000+02:00

The data plays a critical role in the functionality of the app.

Data can be integrated to the Build Apps in the following ways:

Creating Dummy Entities with dummy data or on device storage data.
Creating Entities with the global REST APIs.
Integrating Build Apps with on-premise and fetching the on-premise entities.

We would focus on the most realistic option that is fetching the real-time system data and integration of Build Apps with the OData services created on the on-premise systems.

Design:

We would like to display a simple example where the App would list of products with their respective image, description and MRP maintained in SAP.

The backend OData service would contain an entity ProductsSet that would contain properties of a material like Image, description and MRP.

Integration:

Till now, it has been widely accepted that Build Apps can be accessed from SAP BTP Account. BTP Account must have a cloud connector which would configure the systems connected to the cloud.

In the subaccount, under connectivity, Destinations are configured.

The entire OData URL has been configured as shown below under destination BuildDestination.

Once the destination is configured, we can navigate to the SAP Build Apps.

Under the Auth section, enable the Authentication.

Open Auth (Authentication) → Enable Authentication.

There are three types of Authentication Method in Build Apps.

Google Firebase.
SAP BTP Authentication
Direct Third Party Authentication

We would go for SAP BTP Authentication.

As we need to select the data from the backend, Under the Data tab, select add Integration.

Select Data → Add Integration.

Select SAP Systems->BTP Destinations

The created destination will be showed there, select the Destination.

Once the destination is selected, the list of entities from the Rest service would be displayed.

Click on Install Integration and enable data entity.

Switch to the UI Canvas. Under Data variables, we can create Entities as a variable. Select the entityset that is a collection of records and save.

Switch to the view in the UI Canvas and the UI element used here is Large Image List Item which is which is available in Market Place.

The Repeat with property of the List Container can be bound with the data variables we had set previously.

Select the entityset and save.

The properties, label can be bound to the Maktx of the entityset.

Similarly, price can be bound to the property Description text.

As we need to display the image too, the image can be bound using the formula URL(repeated.current.ImageContent).

Once the binding is completed, The Image, Description and Price of the products could be shown on the screen.

Hurray! A real time Build App with the secure connection to backend is ready!

SAP Datasphere Multilingual Support - Master Data Translation

2024-05-16T10:22:57.119000+02:00

In this blog we will provide you the overview of Master data translation. We will walk you through each case and how it can be visualized in the Analytical Model Preview as well.

This article is the first in the blog post series on multilingual capabilities in SAP Datasphere.

Blog Post #1: SAP Datasphere Multilingual Support - Master Data Translations (this blog)

Blog Post #2: Translating Metadata using the Translation Dashboard in SAP Datasphere

Introduction

Master data text is the descriptive information associated to the respective master data. For example, customers, products, vendors, materials and their hierarchies can have their independent description in their respective text table. In general, the master data or fact data entity has only IDs. In the analytical representation, if the textual data gets fetched it adds more value and additional context to the better understanding.

In SAC stories, displaying the product description rather than their id's gives a better understanding to the visuals.

Master Data Translation within SAP Datasphere can be accomplished through various methods.

Semantic mapping from an attribute within entity
Text Association
Dimension Association
Hierarchy Association

Figure1: Dependent entities of the Analytical Model

Figure2: Text/Dimension Associations in the entity – SALES (fact)

1.Semantic mapping from an attribute within entity

Here Product Id attribute fetching the corresponding description from the attribute Description of the same fact. When an attribute is marked as semantic type Text, it can be referenced in another attribute for Text/Association. Description with Semantic type Text is referenced at Product ID for Text/Association as mentioned in Figure2.

Figure3: Analytical Model Preview - Fetching the description from the same entity.

2. Text Association

Customer ID attribute has the Text association to table Description.

Figure4: SALES – Description Text Association

Based on the Data Access Language the description will be retrieved. Here I have German (Deutsch), and the texts are fetched for the same.

Figure5: Data Access Language Settings

To get the descriptions, we need to enable the ID and Description or Description from Presentations.

Figure6: Analytical Model Preview - Retrieving the description via Direct text association.

3. Dimension Association

Purchase Date is associated to the Time Dimension – Day.

Figure7: Purchase Date – Time Dimension - Day Association

Figure8: Time Dimension – Day, Here the associated Text tables are highlighted.

Since the day Dimension has a text association for months, the description for months is fetched accordingly (refer Figure10) based on the data access language settings.

Select the Hierarchy like below and enable the display of ID and Description from Presentations settings.

Figure9: Hierarchy Selection

Figure10: Analytical Model Preview - Retrieving the description via Dimension text association.

4. Hierarchy Association

SAP datasphere has released the external hierarchy with directory support. Here the language and texts for Hierarchy label and the Node can be retrieved as well. This blog has already addressed the same here - An Introduction to Hierarchy with Directory in SAP Datasphere

Summary

Text tables serve as the core of master data translation. While importing master data, ensure that if you are using the ABAP language codes like E or D, as compared to i18n language codes like de or en, the string length for the language column is set to 1. And this ensures the effective translation of master data if it has ABAP language codes. A cleaner data without any text duplications is recommended for the effective translation.

SAP BTP FAQs - Part 3 (Security)

2024-05-16T11:12:15.061000+02:00

In this blog, I am going to share the list of common questions and answers on SAP BTP. To make it easy, I have categorized it in multiple volumes.

Part 1 — SAP BTP — General Topics

Part 2— SAP BTP — Application Development, Programming Models and Multitenancy

Part 3 — SAP BTP — Security [Current Blog]

Part 4 — SAP BTP — DevOps [To be published 21st May ]

Part 5 — SAP BTP — Side by side Extensibility [To be published 28st May ]

This is part 3, where we will explore questions on security topics in SAP BTP.

Q: What is the difference between platform users and business users in SAP BTP.

Answer:

In SAP BTP, for user-management, all the users are categorized in 2 ways - platform users and business users.

Platform users are usually developers, administrators or operators who deploy, administer, and troubleshoot applications and services on SAP BTP.

Business users use the applications that are deployed to SAP BTP. For example, the end users of SaaS apps or services, such as SAP Workflow service or SAP Cloud Integration, or end users of your custom applications are business users.

Note: You may draw and explain this further as shown in below image.

Q: On a high-level, explain how global account and subaccounts are controlled and managed by administrators.

Answer:

When a customer signs a contract with SAP, one user is created at the global account level. On this level, entitlements are defined, assigning entities and services, including billing information. The global account administrator can initially log on to SAP BTP to manage these entitlements and create directories and subaccounts. To ensure that more than one employee can administer the global account, the administrator needs to create other users at the global account level and assign them administrator permissions.

Typically, a global account consists of various subaccounts. When a global account administrator creates a subaccount, they automatically become the administrator of the subaccount. The subaccount administrator can manage entitlements, service subscription, create other users on the subaccount level and assign roles to the users. Subaccount administrators get administration authorizations for the subaccount only, not for the global account.

Subaccount administrators also create business users, who are consumers of applications and services that are provided on SAP BTP (for example: SAP Business Application Studio) or business applications (SaaS) that were created with the help of the tools and services provided by SAP BTP and deployed in a subaccount. These users can have access to SAP BTP, but they are not able to do any administrative tasks. If a business user only uses a single application on SAP BTP, he or she does not necessarily require access to the SAP BTP cockpit (meaning the subaccount) but to the application only. In this case, the subaccount administrator creates the user on a subaccount level and only assigns application authorizations to the user.

Q: What is the significance/use of SAP XSUAA service in SAP BTP?

Answer:

The SAP Authorization and Trust Management Service (XSUAA) is one of the most important BTP service involved in application security.

Let me first explain what XSUAA is.

SAP XSUAA is an internal development of SAP. In Cloud Foundry, there is an open-source component called UAA. UAA is an OAuth provider which takes care of authentication and authorization. SAP took the base of UAA and extended it with SAP specific features to be used in SAP BTP. Technically XSUAA is an OAuth server and uses JWT tokens.

XSUAA takes care of authentication and authorization in SAP BTP, Cloud Foundry.

XSUAA does NOT store user data. This is why the XSUAA needs to trust an external Identity Provider (IdP). It can establish trust either with SAP ID Service or a Corporate Identity Provider via SAP Identity Authentication Service (IAS).

Q: What is an Identity Provider and why it is required?

Answer:

An Identity Provider (IdP) is a system or service responsible for authenticating users and providing them with access to resources or services within a network or application. It serves as a trusted source for verifying the identity of users and issuing security tokens that can be used for access control.

IdPs are required for several reasons:

Centralized Authentication

Instead of each service or application managing its own authentication system, which can be cumbersome and less secure, an IdP centralizes authentication processes. This not only makes authentication more efficient but also enhances security by enforcing consistent policies and controls.

Single Sign-On (SSO)

IdPs enable SSO, allowing users to access multiple services or applications with just one set of credentials. This enhances user experience by reducing the need to remember multiple usernames and passwords.

User Management

IdPs often include user management capabilities, such as user provisioning, de-provisioning, and user profile management. This allows administrators to efficiently manage user accounts and permissions across various services and applications.

Q: Can you briefly explain the concept of Principal Propagation and an example of its use in SAP BTP?

Answer:

Principle Propagation allows a user to be the user when the request flows through multiple systems. So that we don’t have any technical user in between.

Principal Propagation is

the ability of a system to securely forward or propagate the authenticated user (principal) from a sender to a receiver in a way that the forwarded user information is kept confidential and – even more important – cannot be changed during transit.
Based on a pre-established trust relationship to the sender, the receiver uses this information to logon the user without asking her again for the credential.

Q: What are the Identity Providers available in SAP BTP?

Answer:

In SAP BTP, there are 2 options for Identity Provider – SAP ID Service and SAP Cloud Identity Authentication service (IAS).

SAP ID Service

SAP ID Service is the default identity provider in SAP BTP. It is a pre-configured, standard SAP public IdP (account.sap.com) that is shared by all customers.

SAP Cloud Identity Authentication service (IAS)

For many customers, business users might be stored in corporate identity providers. SAP recommends using SAP Cloud Identity Services - Identity Authentication Service (IAS) as a hub.

We can connect IAS as a single custom identity provider to SAP BTP. Further use IAS to integrate with corporate identity providers.

Q: Can you explain what is SAP ID Service and it’s importance in terms of security in SAP BTP?

Answer:

SAP ID Service is the default identity provider in SAP BTP. It is a pre-configured, standard SAP public IdP (account.sap.com) that is shared by all customers.
SAP ID Service is managed by SAP. Trust to SAP ID service is pre-configured in all BTP subaccounts.

SAP ID service manages the users of official SAP sites, including the SAP developer and partner community. It is the place where the S-Users, P-Users, and D-Users are managed.

Q: In which scenarios, you will suggest the use of SAP Identity Authentication Service (IAS) in SAP BTP?

Answer:

Most customers already have huge on-premises or cloud ecosystem. Their business user data is already available in their corporate identity provider.

When these customers build applications on BTP, an important question comes up - "How can employees authenticate to the applications with known credentials?"

In simple words, customer needs to provide single sign-on for their custom solution on BTP, SAP S/4HANA Cloud, SAP SuccessFactors and other SAP solutions. The answer to this is SAP Identity Authentication Service.

As shown in the above image, IAS can either act as an IdP itself or delegate the authentication to a corporate identity provider. IAS acts a central hub to provide single-sign-on to all SAP cloud applications as well as BTP applications.

Q: Explain the concepts of Role Collections, Roles, and Scopes in SAP BTP.

Answer:

Scopes

Scopes are arbitrary values that express authorizations / access rights in an application or service. Scopes need to be prefixed with an xsappname to make them uniquely identifiable.

Roles

Roles are entities that hold several scopes. Scopes can be put in multiple roles, so you are not limited to have scopes sitting in just one role.

Role Collections

Role collections contain one or more roles. A role can be used in multiples. But it is totally fine to have, for example, a called Admin that only has an admin role.

Role collections are stored as an assignment in the XSUAA and are THE entity that can be assigned to a certain business user.

Q: Can you briefly explain how role collections are assigned to users?

Answer:

Role collections are managed on each SAP BTP level separately. Role collections that exist in the global account do not exist in the subaccounts. Likewise, role collections in subaccounts are not available in the global account.

All users of SAP BTP are stored in identity providers. How you assign users to their authorizations depends on the type of trust configuration with the identity provider. If you're using the default trust configuration with SAP ID service, you assign users directly to role collections. However, if you are using a custom identity provider, you can assign role collections to individual users directly, or you map role collections to user groups or other user attributes defined in the identity provider. This is called federation.

The custom identity provider hosts the business users who can belong to user groups. It is efficient to use federation by assigning role collections to one or more user groups. The role collection contains all the authorizations that are necessary for this user group. This method saves time when you add a new business user. Simply add the users to the respective user groups and the new business users automatically get all the authorizations that are included in the role collection.

Q: What is xs-security.json file and what is the use of it?

Answer:

xs-security.json file, also called Application Security Descriptor is a file that defines the details of the authentication methods and authorization types to use for access to your application.

The xs-security.json file uses JSON notation to define the security options for an application

The xs-security.json file is further used to create XSUAA service instance. For example, we can use below command to create instance of XSUAA service using an xs-security.json file.

cf create-service xsuaa application myxsuaa -c xs-security.json

An example of xs-security.json file.

{
"xsappname" : "app-name",

"tenant-mode": "shared",

"scopes"     : [ {
                    "name" : "$XSAPPNAME.Display",
                    "description" : "display" },
                 ],
"role-templates": [ {
                       "name"                : "Viewer",
                       "description"         : "View all books",
                       "scope-references"    : [
                                          "$XSAPPNAME.Display" ]
                      }
                     ]
}

Q: Explain what OAuth is and how it’s different from SAML.

Answer:

OAuth is an open standard for applications and websites to handle authorization.

OAuth doesn’t share password data but instead uses authorization tokens to prove an identity between consumers and service providers. It is an authentication protocol that allows you to approve one application interacting with another on your behalf without giving away your password.

OAuth:

Avoids storing credentials at the third-party location
Limits the access permissions granted to third parties
Enables easy access right revocation without the need to change credentials

In this way, OAuth mitigates some of the common concerns with authorization scenarios.

SAML vs. OAuth
The Security Assertion Markup Language (SAML) is an open standard based on XML, which many enterprises use for Single-Sign On (SSO).

There are many differences between SAML and OAuth.

SAML uses XML to pass messages, and OAuth uses JSON.
OAuth is much more lightweight and an ideal fit for system-to-system communication. While SAML is geared towards enterprise security.
OAuth uses API calls extensively, which is why mobile applications, modern web applications, game consoles, and Internet of Things (IoT) devices find OAuth a better experience for the user. SAML, on the other hand, uses a session cookie in a browser that allows a user to access certain web pages – great for short-lived work days, but not so great when have to log into your smart watch every day.

Q: What is JWT and how it’s better than SAML tokens?

Answer:

JSON Web Token (JWT) is an open standard that defines a compact and self-contained way for securely transmitting information between parties.

For example, XSUAA creates a JWT token to combine user information from IdP, role collection assignments, etc. and pass it to application.

A JWT consists of three main components that are declared as plain JSON:

header: Declaration of the used hashing and signing algorithms

body/payload: Might be anything, but in our case it is the information about the user, the issuer and all the scopes.

signature: The signature allows the integrity of the JWT. The XSUAA will put the header of the ticket together with the content.

JSON Web Tokens (JWT) are better than SAML tokens in many ways.

First of all, since JSON is less verbose than XML, JWT Tokens are smaller in size, making JWT more compact than SAML. This makes JWT a good choice to be passed over network.

JSON parsers are extremely common in most programming languages because they map directly to objects. Conversely, XML doesn't have a natural document-to-object mapping. This makes it easier to work with JWT than SAML assertions.

Q: Can you explain what SAML is?

Answer:

The Security Assertion Markup Language (SAML) is an open standard based on XML for exchanging authentication and authorization data of a user between an identity provider (IdP) and a service provider (SP).

SAML is a platform for requesting authentication. Its most common use is to enable SSO.

In SAML, the data is exchanged using messages called bearer assertions. A bearer is any party in possession of the assertion. The integrity of the assertion is protected by XML encryption and an XML signature.

SAML addresses the requirement of web browser single sign-on across the Internet.

Q: What is OpenID Connect (OIDC) and how it’s different from SAML?

Answer:

OpenID Connect (OIDC) is a relatively new protocol and is continuously evolving. It was designed with web and mobile applications in mind.

OIDC is an extension of OAuth2, with data structures in JSON format (JWT), and simple HTTPS flows for transport. It is designed to be easy to adopt and use.

SAML has a long track record of providing a secure means of identity data exchange, so it is trusted by many organizations. It is also very feature-rich, covering a wide range of identity requirements.

While, OIDC, being newer and evolving (especially in the European banking sector, with Open Banking), is still lagging behind SAML in terms of features.

If I have missed any important question, please let me know in comment.

Happy Learning!

Next Blog

Part 4 - SAP BTP DevOps [To be published]

SAP Business Technology Platform

2024-05-16T15:41:16.371000+02:00

Some helpful sources on the topic of SAP Business Technology Platform (SAP BTP)

SAP Help Portal
https://help.sap.com/docs/btp

SAP Business Technology Platform resource center
https://www.sap.com/products/technology-platform/resources.html

SAP BTP Guidance Framework
https://help.sap.com/docs/sap-btp-guidance-framework/guidance-framework/what-is-sap-btp-guidance-framework

SAP BTP Developer's Guide
https://help.sap.com/docs/btp/btp-developers-guide/what-is-btp-developers-guide

SAP BTP Learning Journeys
https://learning.sap.com/products

SAP Community
https://community.sap.com/t5/c-khhcw49343/SAP+Business+Technology+Platform/pd-p/73555000100700000172

Have fun learning, trying and using it!

SAP Fiori development newsletter May 2024 (issue #28)

2024-05-16T15:50:00.021000+02:00

What a great time to be in software development! AI is rapidly changing the application development landscape and I’m excited to see new generative AI capabilities appearing across our portfolio. SAP Fiori tools recently added the ability to generate apps from a business requirement document. You can access this and many more cool AI tools in SAP Build Code. This issue focuses on these and other innovations, as well as a sneak peak about what you can expect to see at Sapphire.

If you want to meet with fellow developers and the SAP engineers who build our professional development tools, I encourage you to join our monthly SAP Fiori elements and SAP Fiori tools roundtable group.

Our next meeting is June 12, 2024.

Learn about the group at https://blogs.sap.com/2021/07/31/peer-to-peer-learning-at-the-sap-fiori-elements-and-sap-fiori-tools...
You can also email me if you would like an invitation.

Was this forwarded to you? Subscribe to the SAP Fiori development newsletter.

Your editorial team,
Peter, Oliver, and Raz

Development News

Sapphire 2024 user experience and application development sessions

Here is a list of sessions that highlight user experience and application development, both of which contain varying levels of AI, as SAP is infusing artificial intelligence into most of our solutions.

https://community.sap.com/t5/technology-blogs-by-sap/sapphire-2024-user-experience-and-application-development-sessions/ba-p/13684064

SAP Fiori tools 2403 introduces Gen AI capability and more

The latest enhancements in SAP Fiori tools introduce many exciting features aimed at streamlining the development process and fostering greater collaboration across teams. We have added new generative AI capabilities to create SAP Fiori elements apps directly from a business requirement document.

https://community.sap.com/t5/technology-blogs-by-sap/sap-fiori-tools-2403-introduces-gen-ai-capability-and-more/ba-p/13650594

Unlocking efficiency and simplicity: a look into the new features of SAP Fiori elements for OData V4

The post explains the new functionalities and improvements from SAPUI5 Version 1.121 and SAP Fiori elements for OData V4.

https://community.sap.com/t5/technology-blogs-by-sap/unlocking-efficiency-and-simplicity-a-look-into-the-new-features-of-sap/ba-p/13645297

Building and delivering AI solutions for both developers and end-users in SAP S/4HANA Public Edition

This post shows a sneak preview of some of the AI initiatives we are working on for both application developers and end users. Some are roadmap items that may or may not turn into productive solutions.

https://community.sap.com/t5/technology-blogs-by-sap/building-and-delivering-ai-solutions-for-both-developers-and-end-users-in/ba-p/13699945

ABAP Cloud Developer Trial 2022 available now

ABAP remains an important part of the SAP development landscape. The ABAP Cloud Developer Trial is pre-configured with SAP Fiori launchpad, SAP Cloud Connector, backend / frontend connections, roles, and sample applications.

https://community.sap.com/t5/technology-blogs-by-sap/abap-cloud-developer-trial-2022-available-now/ba-p/13598069

Embracing TypeScript in SAPUI5 development

SAP officially announced TypeScript support for UI5 starting with version 1.116.0. This post explains how this fits into creating SAP Fiori applications.

https://community.sap.com/t5/technology-blogs-by-members/embracing-typescript-in-sapui5-development/ba-p/13675744

Upgrade SAP Business Application Studio to SAP Build Code

Now you can migrate an existing SAP Business Application Studio instance to SAP Build Code. This post explains how.

https://community.sap.com/t5/technology-blogs-by-sap/upgrade-sap-business-application-studio-to-sap-build-code/ba-p/13661500

Create a full-stack app using Joule

This step-by-step post shows how to create one full-stack application for management orders based on a model from the Northwind service. It uses Joule to enhance the app and generate some test scripts.

https://community.sap.com/t5/application-development-blog-posts/create-full-stack-app-use-entity-drafts-use-joule-to-create-action-code/ba-p/13676527

Unlocking full-stack potential using SAP Build Code - part 1

This post shows how to create a simple CAP and UI app using Joule and deploy it to the BTP subaccount. It explains how to test, create a managed app router configuration, and access the UI and service endpoints successfully.

https://community.sap.com/t5/technology-blogs-by-members/unlocking-full-stack-potential-using-sap-build-code-part-1/ba-p/13667300

SAP Build Code - speed up your development with generative AI assistant – Joule

This post explains SAP Joule and how it can be used to generate application logic, data models, SAP Fiori apps, test scripts, sample data, service definitions and more.

https://community.sap.com/t5/technology-blogs-by-sap/sap-build-code-speed-up-your-development-with-generative-ai-assistant-joule/ba-p/13660954

Custom data as table, CDS, domain, business object and all that jazz...

The need for custom data is nothing new, but customizing while keeping a core clean is. Key User and on-stack Developer Extensibility provide many options. This post showcases each option relating to having your own "custom data" in SAP S/4HANA, with some pros and cons and when to use which option.

https://community.sap.com/t5/technology-blogs-by-sap/custom-data-as-table-cds-domain-business-object-and-all-that-jazz/ba-p/13660397

Building low-code extensions with Key User Extensibility in SAP S/4HANA and SAP Build

Key users can make certain changes in SAP systems that can reduce the workload for developers. They can adapt SAP applications and services using low-code tooling that’s built into SAP S/4HANA.

https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/building-low-code-extensions-with-key-user-extensibility-in-sap-s-4hana-and/ba-p/13675437

Unleashing AI magic: building full-stack apps with SAP Build Code

See how to build two different full stack applications with just a few clicks and prompts.

https://community.sap.com/t5/technology-blogs-by-sap/unleashing-ai-magic-building-full-stack-apps-with-sap-build-code/ba-p/13652771

Joule for freestyle SAPUI5 development in SAP Build Code

Joule helps write freestyle SAPUI5 code in SAP Build Code. Ask Joule by typing code-related requests, in natural language, into Joule's chat window. For example, you could ask Joule to insert a control to a view, add an event handler to a controller, introduce a full new view with routing and much more. This post summarizes some of the key capabilities.

https://community.sap.com/t5/technology-blogs-by-sap/joule-for-freestyle-sapui5-development-in-sap-build-code/ba-p/13650005

Our latest roadmaps are available

SAPUI5 roadmap
SAP Fiori elements roadmap
SAP Business Application Studio roadmap
SAP Fiori tools roadmap

Developer Tutorials

New Tutorial: Key User Adaptation for SAPUI5 applications

To extend SAPUI5 applications, SAPUI5 Flexibility offers capabilities not only for developers but also for key users and end users using simple visual / WYSIWYG tools..

https://community.sap.com/t5/technology-blogs-by-sap/new-tutorial-mission-key-user-adaptation-for-sapui5-applications/ba-p/13639694

Tutorial: SAPUI5 Adaptation Projects for SAP S/4HANA Cloud

SAPUI5 Adaptation Projects in SAP Business Application Studio are not new. But what is new is the support for SAP S/HANA Cloud. This enables developers to enhance SAPUI5 applications in SAP S/4HANA Cloud with comprehensive features that were previously exclusive to on-premise customers. See this blog post linking to an extensive, end-to-end tutorial:

https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/extending-sap-s-4hana-cloud-public-edition-using-sapui5-adaptation-projects/ba-p/13607813

Developing and extending SAP Fiori elements apps openSAP course

https://open.sap.com/courses/fiori-ea1

Developer Events

UI5con and reCAP coming in June

The community conferences around UI5 and CAP are coming back in 2024. See the announcements on UI5con and reCAP.

https://openui5.org/ui5con/germany2024/

https://recap-conf.dev/

https://abapconf.org/

These three events together form CodeConnect 2024, which starts the week of June 3.

https://code-connect.dev/

SAP S/4HANA Cloud extensions with SAP Build best practices: an expert roundtable podcast

In this blog adapted from the podcast “SAP S/4HANA Cloud extensions with SAP Build best practices: an expert roundtable”, SAP experts discuss SAP S/4HANA extensibility best practices.

https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/sap-s-4hana-cloud-extensions-with-sap-build-best-practices-an-expert/ba-p/13656552

SAP Fiori Innovation Days - coming later in 2024

Please mark your calendar for the next SAP Fiori Innovation Day events.

Chicago - August 13

Paris - November 19

We will share details and registration information in an upcoming newsletter

Back issues from the past year

SAP Fiori development newsletter #27 (March 2024)

SAP Fiori development newsletter #26 (January 2024)

SAP Fiori development newsletter #25 (November 2023)

SAP Fiori development newsletter #24 (September 2023)

SAP Fiori development newsletter #23 (July 2023)

Syniti RDG provides a simplified design to create Multi Value Validation and Derivation Rules

2024-05-17T12:35:22.385000+02:00

Syniti RDG is an SAP-endorsed application on the Business Technology Platform (SAP BTP) to facilitate MDG
implementation with intuitive UI and process automation. RDG automates many of the technical configuration
steps that are required to implement SAP MDG and it offers a user-friendly interface to be more relatable
to business users.

A multi-value check rule is for validating multiple attribute values against a logical condition.
A multi value derivation rule is to derive multiple attributes values based on a logical condition.

The below example is used to create Multi value validation to be triggered for a specific Change Request Type
to validate attribute values of Entity ‘BP_CENTRL’ of data model ‘BP’.

Step 1: Create Multi Validation Rule in Syniti RDG

In the main menu, select "Manage Business Rules".

In the business Rules Page, define a New Rule: Start by creating a new rule, select the type of rule as "Multivalue Check Rule" to create.

In the following steps, the user can choose a Change request type from the list and select the entity for which
the rule must be created. The user then needs to select the type of Business Rule that he/she wants to create,
Mutli Value Check Rule to create Validation Rule in BRFPlus and Derivation Rule to create Derivation Rule in
BRFPlus.

Select Data model as ‘BP’, ‘ZBP1P1V1’ CR Type (select relevant CR type as required) , Entity as ‘BP_CENTRL’,
Rule type: Multi Value Validation and then click on an option like "Rule1” to start defining a new validation rule.

Business Scenario: Only Green business partners are allowed to create. Choose the attributes
BP_CENTRL~NAME_ORG1 that needs to be validated. If BP_CENTRL~NAME_ORG1 = ‘RED’, send a warning message ‘Enter name1 as Green’

Click’+’ to create "Rule2” validation rule. If BP_CENTRL~NAME_ORG1 = ‘YELLOW’, send a warning message ‘Enter name1 as Green’

Click’+’ to create "Rule3” validation rule. Define a new condition

If BP_CENTRL~NAME_ORG1 = ‘GREEN’ and BP_CENTRL~NAME_ORG2 != ‘CORP’ , When the conditions are not met, send error message ‘Enter name2 as CORP’

Multi value validation BADI implementation has bee created in the back end automatically to check the multi value validation.

Step 2: Trigger the rule in nwbc application.

The rules created in the previous step are triggered when creating a Change Request of the type for which the rules are created in RDG (ZBP1P1V1).

Validation Rule1 :

Now name1 is entered as GREEN, Error message appears for name 2

Validation Rule3:

After successful verification of Validation Rule1 & Rule 3 , ‘No Errors found’

Below is the Decision table that got automatically generated in BRFPlus through Syniti RDG.

Validation Rules created in FMDM Catalog automatically in decision table format

Multi Derivation Rule: Most of the steps are similar to Multi Validation rules, except here we have to mention
the multiple deriving attributes which is derived based on satisfying certain condition

In the business Rules Page, define a New Rule: Start by creating a new rule, select the type of rule as "Multi Value Derivation Rule" to create.

Step 1 : Select Data model as ‘BP’, ‘ZBP1P1V1’ CR Type (select relevant CR type as required) , Entity as ‘BP_CENTRL’,
Rule type: Multi Derivation and then click on an option like "Rule1” to start defining a new derivation rule.

Business Scenario: For all Green business partners, derive multiple attributes like Salutation, Title, BU search term1,
BU search term2 through multi value validation rules, for the ease of understanding, simple business derivations rules are taken and
explained here, there is no restriction to create multiple rules with multiple condition.

If BP_CENTRL~NAME_ORG1 = ‘GREEN’, following attributes will be derived automatically upon successful validation rules

BP_CENTRL~BU_SORT1, BP_CENTRL~BU_SORT2, BP_CENTRL~TITLE_LET, BP_CENTRL~TITLE_BP

After saving the Mutli value derivation business rule thru RDG, Multi value derivation BADI implementation has been
created / updated in the back end automatically to derive multiple attributes

Step 2: Trigger the rule in NWBC application.

Multi Value Derivation Rules created in FMDM Catalog automatically in decision table format

With the help of Syniti RDG, you can now create multi value validation / derivation rules without the effort of creating
Custom BADI implementation in the backend and it simplifies the way of creating decision tables automatically in BRFPlus.

Syniti RDG is a certified SAP BTP solution and is available on SAP App Store.

To know more details about the product, check the blog Partner Add-on Solutions.

Your opinions and feedback are highly appreciated and feel free to post them in the comment section.

Please follow and read more interesting blogs on SAP Master Data Governance | SAP | SAP Blogs

You can also find and post questions about the product here: SAP Master Data Governance Community

SAP BTP ABAP Environment – Release 2405

2024-05-17T21:33:18.532000+02:00

As follow-up to our previous release 2402, this blog post provides an update to our most recent release 2405, which is available for customers and partners on May 18th/ 19th. Please enjoy my little overview of the most important features.

Many thanks to Florian Wahl for his contributions to this blog post!

All available new features can be found on the official release notes page.

ABAP Development Tools

Enhancements to authorization check issue handling relating to authorization object S_DEVELOP (details)
Availability of new editors for launchpad spaces and page template (details)
Support for clear console when running an ABAP application (details)
Support for exporting an ABAP runtime error as ZIP file (details)
Support for display application job catalog entries (details)
Support for ATC checks for knowledge transfer documents (details)
Availability of new property ABAP language version (details)
Support for display of failed assertions and status test methods (details)
Enhancements to large ABAP traces for better handling (details)
Support for ABAP contract check violations feed (details)
Support for custom code migration project scheduling via application jobs (details)
Support for software component relations editor (details)
Support for toggling the step size in the ABAP debugger (details)
Support for launching ABAP unit tests with quick actions (details)
Support for test code highlighting for method calls (details)
Support for quick action usage to insert ABAP unit test class templates (details)
Support for template context while creating metadata extensions (details)
Support for tools bridges between ABAP Development Tools for Eclipse and VS Code/BAS (details)
Support for display remote ATC runs from SAP BTP (details)

ABAP RESTful Application Programming Model

Support for subentities as authorization master that are not defined as root entity
Support for entity assignment of RAP business events
Support for defining result cardinality [1..*] for factory actions

Administration

IP address changes on AWS (details)
Support for display whether dependent business catalog is optional (details)
Support for defining several general restrictions by leading and filter undefined restrictions in Maintain Restrictions UI (details)
Support for factory calendar pull integration from SAP S/4HANA Cloud to SAP BTP, ABAP environment (details)
Support for table analysis of table statistics from aggregated views over time (details)
Support for merging spaces and pages at the same time (details, details)
Support for translation of new CDS annotation: UI.dataPoint.title, EnterpriseSearch.modelName and EnterpriseSearch.modelNamePlural (details)
Support for upload of primary and secondary signing certificate (details)

Integration & Connectivity

Support for setting the AIR key as custom HTTP header field to a SOAP request (details)

Key User Extensibility

Support for user names in Manage View dialog (details)

Reuse Services

Support for usage of source templates to provide content specification of a metadata extension and reading the longtext of a message using the XCO library (details)

Data Access

Support for SQL-based remote access from SAP HANA Cloud databases to ABAP system (details)

Additional Information

You can find the (new) product page on SAP BTP, ABAP Environment | SAP Help Portal

For the new documentation structure, see Standalone Documentation. The new documentation page makes search and navigation for SAP BTP, ABAP environment topics easier.

In addition to the Roadmap Explorer, see SAP BTP, ABAP environment Roadmap for more details on the roadmap items.

As always, please let us know if you have questions.

Stay healthy and take care!

AI@FRE (Part 1) - Enabling Enterprise AI Adoption through the BTP FRE Engagement Model

2024-05-20T14:01:27.023000+02:00

In this blog, we will explore the challenges of adopting Business AI; what use cases are for AI and not for AI; and how enterprises can effectively roadmap their Business AI Adoption Journey with foundational BTP AI Services.

With Business AI, our goal is to maximize business value for customers by providing Relevant, Responsible, and Reliable intelligent capabilities through AI and GenAI. These beneficial applications are evident across various SAP LoBs functions, showcasing the transformative potential of AI in accelerating and reimagining business processes.

SAP Business AI sounds great. Why I haven’t started implementing it yet?

Adopting Business AI involves navigating both technical and non-technical challenges.

Organizations must first develop a clear understanding of how AI can be effectively utilized within their operations. This includes identifying appropriate business use cases for AI, such as automation, analytics, and personalized recommendations; while recognizing that AI is less suitable for tasks requiring high levels of creativity and innovation, mission-critical decision-making, compliance, and handling complex matters, as well as random or overly simple scenarios.

Business Use Cases FOR AI

Business Use Cases NOT for AI

On the non-technical side, one of the primary challenges is incorporating a human element into AI deployments. This means understanding which tasks should remain human-centric and ensuring that AI complements rather than replaces human capabilities. Furthermore, effectively bridging the skills gap is crucial. Organizations must invest in training and development to equip their workforce with the necessary skills to work alongside AI technologies. This balanced approach ensures that AI adoption enhances business operations without undermining the human contributions that are essential for creativity, critical thinking, and complex decision-making.

I Understand the Challenges. What Are the Recommended First Steps for AI Adoption?

The advantage of SAP Business AI is that it seamlessly integrates the right AI capabilities into the appropriate business processes, embedding AI into Cloud LoB applications to make customers' business operations more intelligent. SAP AI Business Services, developed through strong ecosystem partnerships with leading AI model and cloud platform providers, help organizations overcome the complexities of their initial machine learning projects. These services offer easy-to-use, enterprise-ready intelligent solutions that address specific business problems across various processes. By leveraging these capabilities, organizations can further solidify their AI foundation and prepare for more advanced applications.

When organizations begin their journey with AI, focusing on quick-win use cases can set a positive trajectory. For instance, infusing AI into enterprise functions, such as deploying AI co-pilots and digital assistant applications like SAP Joule, can deliver immediate value and demonstrate AI's potential to enhance productivity and efficiency. Digital assistants platform, such as SAP Conversational AI, can improve customer service by providing instant responses to common inquiries, reducing wait times and improving customer satisfaction. These quick wins can build confidence and pave the way for more comprehensive AI integration.

Establishing guardrails is essential to guide AI adoption and ensure long-term success. Standardization is key; without a solid foundation in data management, UX, security setup, and a clean core infrastructure, AI integration efforts are likely to falter. For instance, inconsistent data formats or poor data quality can severely hinder AI performance. A standardized approach ensures that data is clean, well-organized, and secure, providing a reliable foundation for AI applications. Additionally, building AI systems that are responsible, ethical, and explainable is critical. This means ensuring that AI operates transparently, making decisions that can be easily understood and justified, thereby fostering trust and compliance with regulatory standards. For example, in healthcare, an explainable AI model used for diagnosing diseases should provide clear insights into how it arrived at a particular diagnosis, allowing doctors to verify and trust the AI's recommendations. These guardrails help integrate AI responsibly and sustainably, aligning with broader business objectives and setting the stage for long-term success.

Guardrails for Future Ready Business Transformation with AI

Hmmm… That’s good to know but I am a bit lost again in my AI Adoption Journey. Any structure framework to guide me?

Embracing change with new innovation is usually challenging for customers operating within complex environments. The Future Ready Enterprise Engagement (#FRE) Model is designed and developed specifically to help customers Embrace Change, Operate at Pace, and Protect their Core. (To revisit FRE and its value lens to partners / customers, please visit this SAP Blog on #FRE Engagement Model).

The #FRE model also provides a structured approach for adopting AI in their platforms, guiding them from getting started to becoming mature, proficient users of Business AI.

The FRE Engagement Model for Platform Maturity

For organizations looking to adopt AI, #FRE offers a comprehensive roadmap. The journey with BTP Business AI starts by infusing / embedding AI capabilities into operations, focusing on enhancing business functions and standardizing security architecture. As organizations progress, the FRE model guides them in driving business process excellence, standardizing UX architecture, and developing a robust data strategy with ethical and secure AI use. Once these foundations are established, organizations move towards scalable execution, optimizing business processes with reliable AI. The final stage involves creating an Enterprise AI Center of Excellence and implementing Change Management strategies for sustainable AI adoption.

In Part 2 of the AI@FRE Blog Series, we will discover how customers can start with BTP foundational capabilities, to accelerate GenAI capabilities in their business processes.

For more information on BTP FRE Engagement Model and how FRE can establish foundational capabilities for customer's AI Adoption, please feel free to reach out to our team at BTPFRE@sap.com