SAP AI Core — Resource Groups, Scenarios, Executables
As of 2026-09-25
SAP AI Core's object model — scenario, executable, configuration, execution, deployment, artifact — decides whether a client's AI landscape is isolated by design or leaking by default. This module works from SAP's own AI Core service guide to define each object precisely, then focuses on the one decision every project gets wrong at least once: which objects are shared tenant-wide across resource groups (scenarios, executables, Docker registry secrets) and which are scoped to a single resource group and must never be reused across one (executions, deployments, configurations, artifacts, object store credentials). It covers the exact metadata — labels and annotations — that turns a plain Argo WorkflowTemplate into a registered scenario and executable, the Git-repository sync model behind it, serving templates and their KServe InferenceService spec, and the efficiency features (autoscaling, scale-to-zero, scale-to-1, ttl, warm node pool) that make an always-on deployment affordable. Three exercises — read the object model, design a three-environment resource-group layout, write a workflow template's metadata block — and a self-assessment gate the move to M363.
What you will learn
- Name and sequence SAP AI Core's six core objects — scenario, executable, configuration, execution, deployment, artifact — and explain how each is built from the one before it
- State precisely which AI Core objects are shared tenant-wide across resource groups and which are scoped to one, and use that boundary to design a resource-group layout
- Write the mandatory labels and annotations that register an Argo WorkflowTemplate as a scenario and executable, including artifact metadata and globalName
- Explain how a Git-registered repository synchronizes into AI Core's scenario and executable catalog, and why reviewing a client's landscape means reading the repository, not just the tenant
- Read a serving template's KServe InferenceService spec and set minReplicas, maxReplicas and containerConcurrency for a realistic traffic pattern
- Apply AI Core's efficiency features — autoscaling, scale-to-zero, scale-to-1, ttl, warm node pool — to balance cost and latency for a given deployment
Module overview
Who this is for. You have built a proof of concept in the generative AI hub, called a model through orchestration, and now a client asks for a real landscape: separate dev, test and production, a place for a data-science team to run training jobs next to the chatbot workloads, and a story for who can see what. That landscape is SAP AI Core's object model — resource groups, scenarios, executables, configurations, executions, deployments and artifacts — and almost every course skips it because a trial tenant hides it behind one default resource group. This module opens it up, using SAP's own service guide, so you can design a landscape instead of accepting the default one.
Prerequisites
- M333 (AI & LLM Fundamentals for SAP Consultants) or equivalent working knowledge of tokens, embeddings and RAG
- Comfort reading YAML and basic Kubernetes vocabulary (namespace, secret, container image, replica)
- Optional for the hands-on exercises: a trial SAP AI Core tenant (BTP trial) or access to a client tenant with SAP AI Launchpad
Outcomes
- Read an SAP AI Core tenant (via AI Launchpad or the AI API) and correctly name every object you see, in the right relationship to its neighbours
- Design a resource-group layout for a multi-environment, multi-team SAP AI Core landscape, with the shared-versus-scoped boundary made explicit in the design
- Write the metadata that registers a new scenario and executable from a workflow template alone, without a separate creation step
- Configure a serving template's scaling parameters against a stated traffic and cost target, and justify the choice
Full module available to members. The full module adds: the decision framework · the end-to-end scenario walkthrough · the KPI scorecard · the anti-patterns · the code blocks · the knowledge check · the diagrams.