.png)
Amazon SageMaker AI Integration Guide
Connect enterprise applications and data platforms with SageMaker AI through AWS service APIs, S3 data exchange, asynchronous jobs, inference endpoints, and selected EventBridge notifications.
Amazon SageMaker AI integration options at a glance
Amazon SageMaker AI exposes regional HTTPS service APIs using AWS service protocols and JSON operations for managing training jobs, models, endpoints, processing jobs, and batch workloads. AWS SDKs are often preferred because requests require SigV4 signing and structured service-specific payloads. SageMaker supports synchronous endpoint invocation, asynchronous inference, Batch Transform, and long-running training and processing jobs. Amazon S3 is the primary exchange point for datasets, model artifacts, and large inputs or outputs. Selected SageMaker state changes can be routed through Amazon EventBridge. Martini can orchestrate these calls, schedule jobs, map payloads, track identifiers, retrieve results, and expose controlled business APIs.
| Integration point | Supported by Amazon SageMaker AI? | Common use cases | How Martini supports it |
|---|---|---|---|
| AWS service APIs | Limited | Manage TrainingJob, ProcessingJob, TransformJob, Model, EndpointConfig, and Endpoint resources; start jobs, invoke inference, inspect status, and manage tags. SageMaker uses regional HTTPS AWS service protocols rather than conventional REST resource APIs. | Martini can orchestrate HTTPS/API calls and workflows. AWS SigV4 signing, request serialization, regional endpoints, and service-specific payloads must be implemented or supported through SDK-based or custom JVM-compatible logic. |
| SDKs and custom AWS logic | Yes | Use AWS SDK behavior for SigV4 signing, pagination, waiters, complex request structures, and service-specific operations. | Martini can use API orchestration and custom JVM-compatible logic where standard HTTP configuration is insufficient for AWS signing or SDK behavior. |
| Bulk, asynchronous, and batch processing | Yes | Training, ProcessingJob, TransformJob, HyperParameterTuningJob, AutoMLJob, SageMaker Pipelines, and asynchronous inference support long-running or batch workloads. | Martini can submit jobs, persist identifiers, poll or process completion events, retrieve outputs, and route success or failure results. |
| Real-time endpoint invocation | Yes | Invoke persistent SageMaker Endpoint resources synchronously for low-latency predictions. | Martini can expose a controlled API, validate and transform business payloads, invoke the endpoint, normalize the response, and apply timeout and error handling. |
| EventBridge notifications | Limited | Route selected SageMaker resource and job state changes through Amazon EventBridge to Lambda, SNS, SQS, Step Functions, or an appropriate Martini-facing endpoint. | Martini can consume or receive events through a supported endpoint, correlate resource identifiers, and process events idempotently. Polling remains necessary where event coverage is insufficient. |
| Amazon S3 data exchange | Limited | Exchange training data, model artifacts, Batch Transform inputs and outputs, asynchronous inference data, and evaluation results through S3 locations. | Martini can validate and map S3 URIs, coordinate staged files, and process results without embedding large payloads directly in API requests. |
| Feature Store APIs | Yes | Write, read, and manage feature groups and feature records used by machine learning workflows. | Martini can orchestrate Feature Store API calls, map feature data, apply validation, and route feature or processing results to other applications. |
| AWS authentication | Yes | Authenticate SageMaker API calls using SigV4 with IAM users, roles, temporary STS credentials, and resource-scoped policies. | Martini can manage environment-specific configuration and secrets and apply authentication workflows; the implementation must provide correct AWS signing and least-privilege permissions. |
How Amazon SageMaker AI exposes data and business events
Amazon SageMaker AI service APIs
SageMaker provides regional HTTPS service APIs with AWS JSON operations for creating, describing, updating, invoking, and listing SageMaker resources. These APIs are AWS service interfaces rather than conventional REST resource APIs, and calls normally require SigV4 authentication.
Martini implementation pattern
Martini uses a workflow to validate the business request, resolve the AWS Region and resource configuration, construct the service-specific payload, and invoke the SageMaker operation. Where standard HTTP configuration cannot provide the required signing or serialization, custom JVM-compatible logic or an AWS SDK-based intermediary may be required.
Implementation sequence
Asynchronous SageMaker jobs
TrainingJob, ProcessingJob, TransformJob, HyperParameterTuningJob, AutoMLJob, PipelineExecution, and asynchronous inference support long-running execution. Results commonly use Amazon S3 for inputs, outputs, artifacts, or intermediate data.
Martini implementation pattern
Martini submits a job with validated S3 locations and configuration, stores the returned job or execution identifier, and either polls status or processes a supported event. Completion logic retrieves outputs, maps them to the target model, and separates transient, terminal, and timeout conditions.
Implementation sequence
EventBridge notifications
SageMaker publishes selected resource and job state changes to Amazon EventBridge. This is selective event coverage rather than a universal webhook or callback for every SageMaker operation.
Martini implementation pattern
An EventBridge rule routes supported SageMaker events through an AWS target or Martini-facing endpoint. Martini validates the event source and detail, correlates the resource identifier with an active process, applies idempotency checks, and uses direct status APIs or polling when event coverage is insufficient.
Implementation sequence
Synchronous and asynchronous inference
SageMaker supports synchronous invocation of real-time Endpoint resources and asynchronous inference using S3 input and output locations. Batch Transform provides another option for large-scale offline scoring.
Martini implementation pattern
For synchronous inference, Martini exposes or consumes a business API, validates the request, invokes the endpoint, and normalizes the response. For asynchronous or batch inference, Martini stages or references S3 data, starts the operation, tracks completion, and distributes the resulting objects.
Implementation sequence
Amazon S3 data exchange
S3 is SageMaker's normal exchange point for training data, model artifacts, batch inputs and outputs, asynchronous inference data, and evaluation results. SageMaker receives S3 locations rather than acting as a general-purpose file API.
Martini implementation pattern
Martini validates S3 bucket, prefix, Region, encryption, and access configuration, then passes references into SageMaker requests. After processing, it retrieves or routes the resulting object locations and can transform staged data for enterprise consumers.
Implementation sequence
Common Amazon SageMaker AI integration patterns
Pattern 1: Start a SageMaker training pipeline
When to use this pattern
Use this pattern when validated datasets or feature exports should trigger model training. The workflow should correlate the training request with the resulting TrainingJob and model artifacts rather than treating training as a synchronous transaction.
Integration direction
Example Mapping
| Amazon SageMaker AI Field | Canonical Field | Target Field |
|---|---|---|
| InputDataConfig[].DataSource.S3DataSource.S3Uri | trainingInputUri | TrainingJob.InputDataConfig[].DataSource.S3DataSource.S3Uri |
| ResourceConfig.InstanceType | trainingInstanceType | TrainingJob.ResourceConfig.InstanceType |
| OutputDataConfig.S3OutputPath | modelArtifactUri | TrainingJob.OutputDataConfig.S3OutputPath |
| TrainingJobName | executionCorrelationId | TrainingJob.TrainingJobName |
Martini implementation pattern
Martini validates dataset metadata and naming rules, maps environment-specific training configuration, submits the TrainingJob or Pipeline execution, and stores the identifier. A polling or event-driven follow-up handles terminal states, retrieves model artifact metadata, and routes failures without blindly creating duplicate jobs.
Martini capabilities used
- workflows
- API consumption
- data mapping
- validation
- scheduling
- business rules
- error handling
Pattern 2: Expose a business API for real-time predictions
When to use this pattern
Use this pattern when Salesforce, ServiceNow, or a custom application needs predictions without knowing SageMaker endpoint names, AWS credentials, content types, or model-specific payload structures.
Integration direction
Example Mapping
| Amazon SageMaker AI Field | Canonical Field | Target Field |
|---|---|---|
| customerId | subjectId | modelInput.customer_id |
| caseDescription | textInput | modelInput.description |
| EndpointName | modelEndpoint | SageMaker EndpointName |
| prediction | classificationResult | Salesforce prediction field |
Martini implementation pattern
Martini exposes a controlled API, authenticates the caller, validates the model contract, maps the business payload, invokes the SageMaker Endpoint, and normalizes the response. Timeout, endpoint failure, payload rejection, and response-schema changes are routed through explicit error behavior.
Martini capabilities used
- API exposure
- workflows
- authentication and authorization
- data mapping
- business rules
- error handling
Pattern 3: Run scheduled batch scoring
When to use this pattern
Use this pattern when large datasets should be scored periodically without maintaining a real-time request flow. Batch Transform or asynchronous inference can write results to S3 for downstream processing.
Integration direction
Example Mapping
| Amazon SageMaker AI Field | Canonical Field | Target Field |
|---|---|---|
| inputS3Uri | batchInputLocation | TransformJob.TransformInput.DataSource.S3DataSource.S3Uri |
| outputS3Uri | batchOutputLocation | TransformJob.TransformOutput.S3OutputPath |
| schedule | executionWindow | Martini scheduler |
| predictionOutput | scoredDataset | Snowflake staged data |
Martini implementation pattern
A scheduled Martini workflow validates the source object and output prefix, starts the TransformJob, persists the job identifier, and polls or consumes a supported event. After completion it validates output partitions and schema, stages the result for Snowflake or another target, and records partial or failed processing separately.
Martini capabilities used
- scheduled workflows
- API consumption
- file and object orchestration
- data mapping
- validation
- retry handling
Pattern 4: Process model operation events
When to use this pattern
Use this pattern when selected SageMaker training, processing, endpoint, or pipeline state changes should update operational systems or trigger approval and notification workflows.
Integration direction
Example Mapping
| Amazon SageMaker AI Field | Canonical Field | Target Field |
|---|---|---|
| detail-type | eventType | operations.eventType |
| detail.SageMakerResourceName | resourceIdentifier | operations.resourceId |
| detail.TrainingJobStatus | executionStatus | operations.status |
| time | eventTimestamp | operations.occurredAt |
Martini implementation pattern
EventBridge routes supported events to Martini or an AWS intermediary. Martini validates and deduplicates the notification, correlates it with a workflow execution, enriches it with direct SageMaker status when needed, and sends normalized operational data to monitoring or governance systems.
Martini capabilities used
- event-driven workflows
- API exposure
- data mapping
- correlation
- idempotency rules
- error routing
Applications commonly integrated with Amazon SageMaker AI
Amazon SageMaker AI is commonly used with AWS services, data platforms, and business applications that provide training data, invoke models, or consume predictions. Martini can coordinate these systems without exposing AWS credentials or SageMaker-specific request structures to business applications.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Amazon S3 | S3 stores training data, model artifacts, batch inference inputs and outputs, asynchronous inference payloads, and evaluation results. | Amazon S3 → Martini → Amazon SageMaker AI | Martini validates bucket, prefix, Region, and encryption settings, submits S3 locations in SageMaker requests, tracks the job, and retrieves or routes output objects after completion. |
| AWS Lambda | Lambda can provide lightweight preprocessing, postprocessing, event handling, or AWS-specific request signing around SageMaker operations. | Amazon SageMaker AI → Amazon EventBridge → AWS Lambda → Martini | Martini can receive or expose an API for Lambda-mediated operations, normalize payloads, and orchestrate downstream business processing after Lambda or SageMaker completes. |
| Amazon EventBridge | EventBridge routes selected SageMaker job, endpoint, and pipeline state changes to operational or business targets. | Amazon SageMaker AI → Amazon EventBridge → Martini | An EventBridge rule forwards selected events to an appropriate Martini-facing endpoint or intermediary; Martini validates the event, correlates the SageMaker resource, and updates downstream systems idempotently. |
| AWS Step Functions | Step Functions can coordinate multi-stage training, evaluation, approval, deployment, and rollback workflows around SageMaker. | AWS Step Functions → Amazon SageMaker AI → Martini | Martini can initiate or participate in the orchestration, map business parameters into SageMaker operations, and publish normalized status or approval results to enterprise systems. |
| Amazon ECR | ECR stores custom training and inference container images used by SageMaker jobs and models. | Amazon ECR → Amazon SageMaker AI → Martini | Martini validates image and environment configuration, constructs model or training requests, and records image references with the resulting SageMaker resource identifiers. |
| Amazon CloudWatch | CloudWatch provides logs, metrics, alarms, and monitoring data for SageMaker endpoints and workloads. | Amazon SageMaker AI → Amazon CloudWatch → Martini | Martini can consume operational notifications or API results, correlate them with model and endpoint metadata, and route actionable conditions to operations or governance applications. |
| Snowflake | Snowflake can exchange curated training data, predictions, and feature data with SageMaker through staged AWS data flows. | Snowflake → Amazon S3 → Martini → Amazon SageMaker AI | A Martini workflow coordinates extraction or staging, validates S3 locations and schemas, starts SageMaker processing or training, and distributes results back to Snowflake or another governed store. |
| Salesforce | Salesforce business processes can use SageMaker predictions for customer, lead, opportunity, classification, or service scenarios. | Salesforce → Martini → Amazon SageMaker AI → Martini | Martini exposes a controlled business API or consumes Salesforce events, maps the business payload to the model contract, invokes the endpoint, normalizes the prediction, and writes the result back to Salesforce. |
How to build a Amazon SageMaker AI integration in Martini
Objective
Establish the AWS account, Region, resource, IAM role or temporary credential, S3, ECR, KMS, and network configuration required by the integration.
Instructions in Martini
- Create environment-specific AWS configuration outside workflow logic.
- Use IAM roles or temporary credentials where the deployment architecture supports them.
- Provide least-privilege permissions for SageMaker, S3, ECR, CloudWatch, and KMS operations.
- Confirm whether SigV4 signing requires SDK-based or custom implementation.
Objective
Select the event, API request, scheduler, file or object availability signal, or EventBridge route that starts the integration.
Instructions in Martini
- Use a Martini API for request-driven inference or job submission.
- Use a scheduler for recurring batch scoring or status reconciliation.
- Use selected EventBridge notifications where the required SageMaker event type is available.
- Use polling when event coverage does not provide the required state transition.
Objective
Receive the source payload or locate the S3 objects and SageMaker resources required for the operation.
Instructions in Martini
- Validate S3 URI, Region, bucket, prefix, permissions, and encryption settings.
- Retrieve paginated SageMaker lists using NextToken until no continuation token remains.
- Persist job names, endpoint names, pipeline execution identifiers, and other correlation values.
- Avoid placing large datasets directly in workflow payloads.
Objective
Coordinate the SageMaker operation and its dependent steps as a durable Martini workflow.
Instructions in Martini
- Construct the AWS service request or invoke the approved SDK-based operation.
- Separate submission, monitoring, completion, and failure processing.
- Use bounded timeouts and explicit terminal-state handling.
- Keep creation operations safe from duplicate retries through deterministic naming or suitable idempotency controls.
Objective
Convert application payloads, SageMaker request structures, model inputs, and outputs between their respective schemas.
Instructions in Martini
- Map business fields to the model input contract.
- Normalize prediction responses and SageMaker status values.
- Transform staged S3 output into the target application's format.
- Version mappings when model artifacts, feature names, content types, or response structures change.
Objective
Enforce validation, routing, approval, model-version, deployment, and operational policies around SageMaker resources.
Instructions in Martini
- Reject incomplete or incompatible model input before endpoint invocation.
- Apply rules for allowed Regions, endpoints, model versions, and data classifications.
- Route failed or low-confidence outcomes according to the consuming application's policy.
- Enforce cleanup, rollback, and approval behavior for endpoint lifecycle changes.
Common Amazon SageMaker AI data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| TrainingJob | Defines a model training execution, including input channels, training image, output location, compute resources, and stopping conditions. | Amazon S3, Amazon ECR, Amazon EventBridge, AWS Step Functions, CloudWatch | Martini validates the training request, maps S3 and container settings, submits the job, persists the job name, and monitors terminal status with bounded retries. |
| Model | Represents deployable model artifacts and the inference container used to serve predictions. | Amazon S3, Amazon ECR, EndpointConfig, Endpoint | Martini creates or updates model metadata, records artifact and image references, and coordinates the dependency on EndpointConfig and Endpoint resources. |
| Endpoint | Persistent real-time inference resource that receives prediction requests. | Business applications, Salesforce, ServiceNow, CloudWatch | Martini can expose a business API over the endpoint, transform request and response schemas, enforce validation, and handle latency or service failures. |
| EndpointConfig | Defines production variants, model assignments, instance configuration, and traffic distribution for an endpoint. | Model, Endpoint, CloudWatch | Martini maps deployment and routing settings, applies environment-specific rules, and supports controlled update or rollback workflows. |
| ProcessingJob | Runs data processing, feature engineering, evaluation, or preparation workloads. | Amazon S3, Feature Store, EventBridge, CloudWatch | Martini submits the job with validated inputs, tracks the identifier, retrieves output locations, and distributes transformed results. |
| TransformJob | Runs batch inference against a dataset without requiring a persistent real-time endpoint. | Amazon S3, CRM platforms, data warehouses, reporting systems | Martini starts the job, monitors completion, reads the S3 output location, transforms prediction results, and delivers them to target systems. |
Authentication and security considerations
AWS authentication and authorization
Amazon SageMaker AI normally uses AWS Signature Version 4 with IAM users, roles, or temporary STS credentials. Martini workflows must account for request signing, regional endpoints, service-specific permissions, and environment-specific AWS configuration.
Least privilege
- Restrict IAM permissions to required SageMaker actions, resources, Regions, S3 paths, ECR repositories, and KMS keys.
- Prefer roles or temporary credentials over embedded long-lived access keys.
- Separate secrets and environment configuration from workflow logic.
- Review cross-account, VPC, KMS, and resource-policy requirements before production deployment.
Operational considerations for Amazon SageMaker AI integrations
Reliability and scale
SageMaker applies API throttling, service quotas, endpoint capacity limits, and workload-specific concurrency constraints. Use bounded retries with exponential backoff and jitter, and distinguish transient failures from terminal job states.
Asynchronous execution
Training, processing, batch transform, pipeline, and asynchronous inference operations require correlation identifiers, timeouts, polling or selected EventBridge events, and idempotent completion handling.
Data and schemas
- Use S3 for large inputs, outputs, and model artifacts rather than embedding them in API payloads.
- Handle NextToken pagination for list operations.
- Validate model input and output contracts, content types, feature names, and model versions.
- Review Region, account, VPC, subnet, security group, S3, ECR, CloudWatch, and KMS dependencies.
- Test endpoint lifecycle changes, rollback paths, event duplication, and partial failures before production rollout.
Why use Martini instead of scripts or point-to-point integrations?
Orchestrate more than an API call
Direct scripts often combine AWS signing, polling, mapping, retries, credentials, and business rules in code that is difficult to govern. Martini provides workflows and APIs for coordinating these concerns across SageMaker, S3, AWS event routes, and enterprise applications.
Reuse and maintainability
Martini can expose a stable business API over SageMaker endpoints, centralize validation and transformations, and reuse integration logic across training, inference, batch scoring, and operational processes.
- Keep AWS credentials and environment settings separate from integration logic.
- Apply consistent error routing, timeout, retry, correlation, and audit behavior.
- Support scheduled, event-driven, API-led, and asynchronous workflows in one integration design.
- Change target mappings or model contracts without duplicating point-to-point scripts.
Frequently asked questions
SageMaker AI can be integrated through its regional AWS service APIs, SDKs, synchronous and asynchronous inference, training and processing jobs, Batch Transform, Amazon S3 data exchange, SageMaker Feature Store APIs, and selected Amazon EventBridge notifications. AWS IAM and SigV4 are used for authentication, while S3 commonly handles large inputs, outputs, and model artifacts.
Yes. Martini can orchestrate SageMaker service API calls, invoke real-time endpoints, submit and monitor asynchronous jobs, coordinate S3-based data exchange, process selected EventBridge notifications, expose business APIs, and map SageMaker results to enterprise applications. AWS SigV4 signing or SDK-specific behavior may require custom implementation or an AWS intermediary.
No. A dedicated Amazon SageMaker AI connector is not required. Martini can integrate using SageMaker's AWS service APIs, SDK or custom request logic, S3 data exchange, selected EventBridge events, IAM authentication, and related AWS endpoints confirmed for the solution.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Amazon SageMaker AI. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from AWS, infrastructure providers, or other third-party systems based on subscriptions, API usage, compute, storage, networking, and deployment choices.
Use the documented AWS service APIs or SDKs for resource management and endpoint operations, with SigV4 and IAM authentication. Use S3 for large datasets and artifacts, Batch Transform or asynchronous inference for large workloads, and EventBridge for selected state notifications. SageMaker GraphQL and SOAP APIs were not confirmed.
SageMaker does not provide a universal webhook for every operation. It publishes selected resource and job state changes to Amazon EventBridge, which can route events through AWS targets or an appropriate Martini-facing endpoint. Polling or direct status APIs may still be required for unsupported event coverage.
A Martini workflow submits the operation, persists the TrainingJob, ProcessingJob, TransformJob, Endpoint, or PipelineExecution identifier, and polls status or processes a supported EventBridge notification. After completion, it retrieves S3 outputs or inference results, applies mapping and business rules, and writes a normalized result to downstream systems.
Martini can validate requests, apply bounded exponential backoff for throttling and transient failures, enforce timeouts, and route terminal errors for review. Resource creation requires deterministic naming or suitable idempotency controls so retries do not create duplicate jobs, models, endpoints, or configurations. Completion processing should also be idempotent because events can be asynchronous or repeated.
Related Martini documentation
APIs
Workflows
Data
Integrate Amazon SageMaker AI with Martini
Use Martini to connect SageMaker AI models, jobs, endpoints, S3 data, AWS events, and enterprise applications through governed APIs and maintainable workflows.