Ellipse Gradient for Header

Azure Blob Storage Integration Guide

Integrate Azure Blob Storage with enterprise systems through its REST API, Event Grid notifications, secure file operations, and scheduled Martini workflows.

Azure Blob Storage integration options at a glance

Azure Blob Storage provides a REST API for containers, blobs, metadata, leases, snapshots, versions, copying, and multipart block uploads. It also supports SDK-based access, Blob Batch operations, asynchronous copy, and change feed patterns for bulk or incremental processing. Azure Event Grid provides notifications for selected events such as BlobCreated and BlobDeleted, rather than universal callbacks for every operation. Authentication can use Microsoft Entra ID, managed identities, Shared Key, SAS, or user delegation SAS. Martini can consume these APIs, receive Event Grid deliveries through an exposed endpoint, schedule polling workflows, transform file contents, and coordinate downstream processing.

Integration pointSupported by Azure Blob Storage?Common use casesHow Martini supports it
REST APIsYesThe Azure Storage REST API supports container and blob creation, listing, upload, download, copy, deletion, metadata, tags, leases, snapshots, versions, and access policies.Martini can consume REST endpoints from workflows, construct authenticated requests, process continuation tokens, and map responses into downstream models.
Webhooks / outbound callbacksLimitedAzure Event Grid delivers selected events such as Microsoft.Storage.BlobCreated and Microsoft.Storage.BlobDeleted. It is not a universal callback for every Blob Storage operation.Martini can expose a REST endpoint or workflow trigger to receive Event Grid deliveries, validate events, retrieve the current blob, and handle duplicate delivery.
Bulk / async / batch APIsYesBlob Batch supports selected multi-operation requests, while block staging and committing, asynchronous copy, and change feed support large-volume or asynchronous processing.Martini can orchestrate block-upload steps, invoke batch or copy operations, track asynchronous status, and persist processing checkpoints.
File / attachment APIsYesBlob Storage supports streaming uploads and downloads, range reads, block-based large-file uploads, server-side copy, metadata, tags, snapshots, and versions.Martini can retrieve or write file content, transform JSON, XML, CSV, or other payloads, and route files to enterprise applications or APIs.
AuthenticationYesSupported authorization methods include Microsoft Entra ID OAuth 2.0, managed identities, Shared Key, SAS, user delegation SAS, and protected connection strings.Martini can use secured environment configuration for Azure credentials and secrets, with workflows applying the least-privilege access required by the operation.
SDKs and client librariesYesMicrosoft provides Blob Storage libraries for languages including .NET, Java, JavaScript or TypeScript, Python, and Go, commonly handling retries, streaming, pagination, and request construction.Martini primarily consumes the documented REST API; custom JVM-compatible logic can be used where a client-library behavior or specialized upload flow is required.
Change feedYesBlob change feed provides an ordered, durable log of changes when enabled and can support incremental processing designs.Martini can schedule workflows to consume or coordinate change information, retrieve affected blobs, apply idempotency rules, and store checkpoints.
GraphQL APIsNoAzure Blob Storage does not expose a standard native GraphQL API for blob operations.Martini should use the Azure Storage REST API or a separately exposed Azure service rather than assuming a Blob Storage GraphQL endpoint.
SOAP APIsNoNo native SOAP API was identified for Azure Blob Storage operations.Martini should use the Azure Storage REST API or an intermediary Azure service if SOAP is required elsewhere in the architecture.

How Azure Blob Storage exposes data and business events

Azure Blob Storage REST APIs

The Azure Storage REST API is Blob Storage's primary programmatic interface. It supports containers, blobs, metadata, tags, leases, snapshots, versions, copying, listing with continuation tokens, and block-blob upload operations.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates against the configured Blob endpoint, invokes the required REST operation, validates the response, maps the returned object or file metadata, and routes the result to the next system. For large files, the workflow can coordinate block uploads or range-based reads rather than loading the complete object into memory.

Implementation sequence

Authenticate the workflow using the configured Azure authorization method
Invoke the required container or blob REST operation
Follow continuation tokens for paginated listings
Stream or stage large file content as appropriate
Validate the response, ETag, version, and content metadata
Map the result to the target application or canonical model

Azure Event Grid notifications

Azure Blob Storage can publish selected events through Azure Event Grid, including BlobCreated and BlobDeleted, with additional events applicable to particular account configurations. Event coverage depends on the storage account and operation.

Martini implementation pattern

Martini implementation pattern: expose a controlled REST endpoint or workflow trigger for Event Grid delivery, implement the required validation, derive an idempotency key, and retrieve the current blob before transforming or forwarding it. Because delivery can be retried and a blob may be delayed, replaced, or deleted, the workflow should distinguish transient retrieval failures from permanent errors.

Implementation sequence

Receive the Event Grid delivery at a Martini endpoint
Complete Event Grid validation and verify the event source
Derive a stable processing key from the event and blob identifiers
Retrieve the current blob and verify its availability
Transform or route the blob content and metadata
Record the outcome and return an appropriate delivery response

Bulk and asynchronous blob operations

Blob Storage supports Blob Batch for selected operations, staged block-blob uploads, asynchronous server-side copy, and change feed for ordered change tracking when enabled.

Martini implementation pattern

Martini implementation pattern: orchestrate high-volume operations in bounded batches, retain operation state, and separate submission from completion where Azure performs work asynchronously. Workflows can persist checkpoints and retry only the failed or incomplete unit rather than replaying an entire batch.

Implementation sequence

Partition the workload into bounded operation groups
Submit batch, block, copy, or change-feed requests
Persist request identifiers and processing checkpoints
Poll or retrieve completion state when the operation is asynchronous
Retry transient failures with bounded backoff
Commit successful results and isolate failed items

Scheduled Blob Storage synchronization

Martini can periodically list containers or blobs using prefixes, continuation tokens, metadata, versions, or change-tracking information. This provides an alternative when Event Grid is not appropriate or when reconciliation is required.

Martini implementation pattern

Martini implementation pattern: a scheduled workflow reads pages of blobs, filters candidates using naming and metadata rules, compares stable identifiers such as ETags or version IDs with stored checkpoints, and forwards only eligible objects. The workflow records processing state so later executions can resume without assuming that one listing contains all blobs.

Implementation sequence

Start the workflow on a configured schedule
List blobs using prefixes and continuation tokens
Filter objects by metadata, version, ETag, or processing state
Retrieve and validate each eligible blob
Send the transformed result to the target system
Persist checkpoints and reconcile unsuccessful items

Common Azure Blob Storage integration patterns

Pattern 1: Archive application documents in Blob Storage

When to use this pattern

Use this pattern when documents or generated files from a business application must be stored in a governed, scalable object store. It supports structured naming, metadata, duplicate detection, and returning a durable storage reference to the source application.

Integration direction
Salesforce or ServiceNow
Martini
Azure Blob Storage
Example Mapping
Azure Blob Storage FieldCanonical FieldTarget Field
source document identifierdocument.idblob metadata.sourceId
document namedocument.fileNameblob.name
document content typedocument.contentTypeHTTP Content-Type
business object identifierdocument.parentIdblob index tag.parentId
Martini implementation pattern

Martini receives the document or its metadata, validates content type and naming inputs, derives a container and blob path, and uploads the content through the Azure Storage REST API. It can use ETags or an application correlation ID for duplicate detection, apply retryable error handling, and return the blob URL, version ID, or ETag to the source system after a successful write.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • file handling
  • business rules
  • error handling
  • secure environment configuration

Pattern 2: Process newly created blobs from Event Grid

When to use this pattern

Use this pattern when downstream processing should begin after a file is created. It is suitable for document validation, data extraction, transformation, notification, or delivery to another API, while accounting for selected event coverage and retryable delivery.

Integration direction
Azure Blob Storage
Azure Event Grid
Martini
Azure Functions
Example Mapping
Azure Blob Storage FieldCanonical FieldTarget Field
subjectevent.resourcePathfunction.blobPath
data.urlblob.urlprocessing.sourceUrl
data.eTagblob.etagprocessing.sourceETag
event.idevent.idprocessing.idempotencyKey
Martini implementation pattern

Martini exposes an endpoint for Event Grid delivery, validates the event and source, derives an idempotency key, and retrieves the current blob. It validates the file before forwarding content or normalized metadata to Azure Functions or another target. Transient retrieval failures can be retried, while deleted objects, invalid events, and authorization failures are routed to controlled error handling.

Martini capabilities used
  • REST API exposure
  • workflow triggers
  • API consumption
  • data validation
  • data transformation
  • idempotency rules
  • error handling

Pattern 3: Deliver scheduled Blob Storage exports

When to use this pattern

Use this pattern when files must be polled and delivered to a business application or external API on a schedule. It is useful when events are unavailable, when reconciliation is required, or when a target system expects periodic file delivery.

Integration direction
Azure Blob Storage
Martini
Salesforce or ServiceNow
Example Mapping
Azure Blob Storage FieldCanonical FieldTarget Field
blob.nameexport.fileNameexternalAttachment.fileName
blob.properties.contentLengthexport.sizeexternalAttachment.size
blob.eTagexport.sourceVersionexternalAttachment.sourceVersion
blob metadata.processingStatusexport.statusprocessing.state
Martini implementation pattern

A scheduled Martini workflow lists blobs by prefix, follows continuation tokens, filters by metadata or version state, downloads eligible files, and maps their contents to the target API. It records the ETag, version ID, or blob path as a checkpoint and uses bounded retries so a failed delivery does not cause unrelated files to be replayed.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • pagination handling
  • file processing
  • data mapping
  • checkpoint management
  • retry logic

Pattern 4: Replicate external files into Blob Storage

When to use this pattern

Use this pattern for backup, archival, migration, or controlled replication from an external API, file service, or database export into Azure Blob Storage. It emphasizes large-file handling, naming conventions, integrity checks, and retention-aware operations.

Integration direction
External API or file service
Martini
Azure Blob Storage
Example Mapping
Azure Blob Storage FieldCanonical FieldTarget Field
external file identifierfile.idblob metadata.sourceId
external file namefile.nameblob.name
external checksumfile.checksumblob metadata.checksum
export timestampfile.createdAtblob index tag.exportedAt
Martini implementation pattern

Martini retrieves or receives the external file, validates its format and checksum where available, derives a safe blob path, and performs a streaming or block-based upload. The workflow can apply content-type and retention metadata, retry transient Azure failures, and record completion only after the upload and any required commit operation succeed.

Martini capabilities used
  • workflows
  • file and stream handling
  • data validation
  • data mapping
  • business rules
  • large-file orchestration
  • error handling

Applications commonly integrated with Azure Blob Storage

Azure Blob Storage commonly participates in Microsoft data, automation, analytics, and document-exchange architectures. Martini can coordinate Blob Storage with the following named applications using REST APIs, event notifications, scheduled workflows, and file transformations. The exact direction and object handling depend on the permissions and APIs exposed by the adjacent application.

Application Scenario Direction Martini Pattern
Azure Data Factory Move, transform, and schedule data transfers involving files stored in Azure Blob Storage. Azure Blob Storage → Martini → Azure Data Factory Use a Martini workflow to identify or receive Blob Storage files, validate metadata and processing state, and invoke the relevant Azure Data Factory API or downstream handoff. Store correlation and retry information for asynchronous operations.
Azure Functions Run application code when Blob Storage events occur or process files asynchronously. Azure Blob Storage → Event Grid → Martini → Azure Functions Receive selected Event Grid notifications through a Martini API, validate the event, retrieve the current blob, and forward metadata or content to an Azure Functions endpoint with idempotency and retry controls.
Azure Logic Apps Coordinate file movement, approvals, notifications, and external service calls around Blob Storage content. Azure Blob Storage → Martini → Azure Logic Apps Use scheduled or event-driven workflows to list or retrieve blobs, apply validation and mapping, and call Logic Apps with normalized metadata or file content. Handle transient failures separately from authorization and missing-resource errors.
Azure Synapse Analytics Make curated files and extracts in Blob Storage available for analytical processing. Azure Blob Storage → Martini → Azure Synapse Analytics Use Martini to validate file names, formats, metadata, and completion markers before delivering files or invoking a Synapse-related process. Track the blob version, ETag, and processing outcome.
Azure Databricks Process large-scale analytical files and machine-learning inputs stored in Azure storage. Azure Blob Storage → Martini → Azure Databricks Use Martini to detect eligible blobs, apply naming and metadata rules, and notify or invoke the Databricks-side process. Use stable processing keys and bounded retries for repeated events or delayed availability.
Salesforce Archive Salesforce documents or exchange generated exports and business files with Blob Storage. Salesforce → Martini → Azure Blob Storage Receive document metadata or content from Salesforce, validate the payload, construct a governed container and blob path, and upload the file through the Azure Storage REST API. Return a storage reference and preserve source identifiers.
ServiceNow Store or archive ServiceNow attachments and exchange operational files outside the ServiceNow platform. ServiceNow → Martini → Azure Blob Storage Retrieve attachment content and metadata from ServiceNow, map it to Blob Storage naming and metadata conventions, upload it securely, and record the blob URL, version, or ETag back in the originating workflow.
Power BI Use curated files or extracts stored in Blob Storage as inputs for reporting workflows. Azure Blob Storage → Martini → Power BI Use Martini to validate and curate files before making them available to the reporting flow or invoking an adjacent Azure data service. Treat the integration as file and extract delivery rather than a direct Blob Storage business-object integration.

How to build a Azure Blob Storage integration in Martini

Objective

Configure the Azure Blob Storage endpoint and select an authorization model appropriate to the deployment, preferably Microsoft Entra ID or a managed identity where supported by the environment.

Instructions in Martini

  • Store tenant, client, managed identity, SAS, or other sensitive values in secured environment configuration
  • Use the narrowest container and operation permissions required
  • Verify network reachability, private endpoint, firewall, and storage-account access requirements

Objective

Select an event-driven, scheduled, or API-led entry point based on the required delivery behavior and the Blob Storage events available for the account.

Instructions in Martini

  • Use a Martini REST endpoint for selected Event Grid deliveries
  • Use a scheduler for polling, reconciliation, or change-feed coordination
  • Use an API-triggered workflow when another application initiates the transfer

Objective

Receive event metadata or retrieve containers and blobs through the Azure Storage REST API, while handling pagination and large-file behavior explicitly.

Instructions in Martini

  • Validate Event Grid delivery and event source before processing
  • Follow continuation tokens when listing blobs
  • Use streaming, range reads, or block operations for large files
  • Capture ETags, version IDs, blob paths, and correlation identifiers

Objective

Coordinate the storage operation, transformations, downstream calls, checkpoints, and compensating or retry behavior in a maintainable Martini workflow.

Instructions in Martini

  • Separate transient failures from authorization, validation, and missing-resource errors
  • Apply idempotency rules before repeating business actions
  • Persist checkpoints for scheduled and asynchronous processing
  • Use conditional headers or leases where concurrency requires coordination

Objective

Normalize blob metadata and content into a canonical model or target-specific payload before forwarding it to another application or writing it back to storage.

Instructions in Martini

  • Validate file format, encoding, content type, and required metadata
  • Map container, blob, ETag, version, and tag information to target fields
  • Apply safe naming and path conventions
  • Transform JSON, XML, CSV, or other supported payloads according to the target contract

Objective

Enforce routing, duplicate detection, retention, approval, and content eligibility rules before committing the integration result.

Instructions in Martini

  • Reject unsafe or invalid blob names and paths
  • Use event ID, blob URL, ETag, version ID, or correlation ID as a processing key
  • Determine whether the workflow operates on the current blob, a version, or a snapshot
  • Route poison files and unsupported content to controlled exception handling

Common Azure Blob Storage data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Storage accountProvides the Blob Storage namespace, endpoint, redundancy configuration, security settings, and access controls.Azure Data Factory, Azure Synapse Analytics, Azure Databricks, Azure Functions, enterprise applicationsMartini stores the account endpoint and environment-specific access configuration securely, while workflows operate on the required containers and blobs.
ContainerGroups blobs logically and provides a scope for organization, access policies, and processing conventions.Business applications, Azure Functions, Azure Data Factory, Logic AppsMartini can create, list, or validate containers and apply routing rules based on container names, prefixes, and environment configuration.
BlobRepresents an individual stored object such as a document, image, export, backup, log, or application-generated file.Salesforce, ServiceNow, Azure Functions, Azure Synapse Analytics, external APIsMartini can list, upload, download, copy, delete, inspect, and transform blobs while preserving content type, ETag, version, and correlation information.
Block blobStores general-purpose files and supports staged block uploads for large or multipart content.Data pipelines, document systems, backup repositories, analytics servicesMartini can orchestrate block staging and commit operations, apply bounded retries, and avoid treating partially staged content as a completed file.
Blob versionRetains a previous version of a blob when versioning is enabled and supports controlled reads or recovery.Audit systems, document archives, compliance workflows, downstream APIsMartini can use version identifiers in processing keys and explicitly select the current blob or a particular version when retrieving content.
Blob metadata and index tagsStores application-defined key-value information and searchable tags used for classification, routing, and processing state.Workflow systems, analytics processes, document archives, operational databasesMartini can read, validate, set, and map metadata or tags to canonical fields and downstream application attributes.

Authentication and security considerations

Use least-privilege Azure authorization

Azure Blob Storage supports Microsoft Entra ID OAuth 2.0, managed identities, Shared Key, SAS, user delegation SAS, and connection strings. Prefer Microsoft Entra ID or managed identities for long-running enterprise integrations where the deployment architecture supports them.

  • Assign only the required Azure RBAC role, such as Storage Blob Data Reader or Storage Blob Data Contributor.
  • Keep account keys, SAS tokens, and connection strings in secured Martini environment configuration rather than workflow definitions.
  • Use short-lived, narrowly scoped SAS permissions when delegated access is required.
  • Use HTTPS and ensure the Martini runtime can reach private endpoints, firewalls, and virtual-network restricted storage accounts.

Protect files and access paths

Validate blob names, containers, content types, and metadata before processing. Apply explicit authorization when exposing Blob Storage content through a Martini API, and avoid returning unrestricted storage access to callers.

Operational considerations for Azure Blob Storage integrations

Plan for pagination and large files

Blob listings use continuation tokens, so workflows must continue until all pages are processed. Large files may require streaming, range reads, staged blocks, and commit operations rather than a single in-memory request.

Handle retries and duplicate delivery

  • Use bounded retries with backoff for throttling and transient service failures.
  • Use event IDs, blob URLs, ETags, version IDs, or correlation IDs as idempotency keys.
  • Expect Event Grid delivery retries and possible delays between notification and blob availability.
  • Separate retryable failures from authorization, validation, deleted-resource, and unsupported-content errors.

Control concurrency and lifecycle behavior

Use ETags, conditional headers, or leases when concurrent workflows could overwrite the same blob. Explicitly account for versioning, snapshots, soft delete, storage tiers, archive rehydration, retention policies, and content-type or encoding validation.

Test and monitor operational paths

Test pagination, partial uploads, duplicate events, deleted blobs, schema changes in file content, private-network access, and recovery from interrupted workflows. Preserve correlation information and monitor workflow logs and Azure-side delivery or storage errors.

Why use Martini instead of scripts or point-to-point integrations?

Coordinate more than a single storage call

Scripts can upload or download a file, but enterprise integrations also require authentication management, validation, routing, transformation, retries, idempotency, downstream API calls, and operational visibility. Martini models that behavior as reusable workflows and APIs.

Keep integration logic maintainable

  • Separate Azure Blob Storage access from business rules and target-system mappings.
  • Reuse authentication, transformation, validation, and error-handling logic across workflows.
  • Support REST API consumption, Event Grid webhook reception, scheduling, file processing, and controlled API exposure.
  • Apply consistent checkpoints, retry policies, and correlation handling across scheduled and event-driven flows.

Adapt as requirements change

Martini can add new targets, file formats, routing rules, and business validations without duplicating point-to-point scripts. Custom logic can be introduced when a specialized upload, transformation, or coordination requirement is not covered by standard workflow behavior.

Frequently asked questions

How can Azure Blob Storage be integrated with enterprise systems?

Azure Blob Storage can be integrated through its REST API for containers, blobs, metadata, copying, versions, snapshots, and block uploads. Selected Blob Storage events can be delivered through Azure Event Grid, while scheduled workflows can list and process blobs using prefixes, continuation tokens, metadata, versions, or change-tracking information.

Can Martini integrate with Azure Blob Storage?

Yes. Martini can consume Azure Blob Storage REST APIs from workflows, upload and download files, list and manage blobs, transform content, and expose an endpoint to receive selected Azure Event Grid webhook deliveries. The supplied Martini documentation does not confirm a dedicated native Azure Blob Storage connector.

Do I need a connector to integrate Azure Blob Storage with Martini?

No. A dedicated Azure Blob Storage connector is not required. Martini can use Azure Blob Storage's native REST APIs, supported authentication methods, file operations, and Event Grid notifications through workflows and exposed APIs.

Is there any extra Lonti cost to integrate Azure Blob Storage with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Azure Blob Storage. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Microsoft Azure, infrastructure, Event Grid, storage transactions, data transfer, identity, or other third-party services.

Which Azure Blob Storage integration methods should be used?

The Azure Storage REST API is the primary method for current integrations. Use Event Grid for selected event-driven scenarios, scheduled listing for polling or reconciliation, and block, batch, asynchronous copy, or change-feed patterns for high-volume and asynchronous processing. Azure Blob Storage does not provide native GraphQL or SOAP APIs.

Are Blob Storage events or webhooks available?

Azure Blob Storage can publish selected events through Azure Event Grid, including BlobCreated and BlobDeleted, with additional events applicable to certain account configurations. This is limited event notification rather than a universal callback for every storage operation. Martini can receive Event Grid webhook deliveries through an exposed REST endpoint.

How does synchronization with Azure Blob Storage work?

Synchronization can be event-driven or scheduled. An Event Grid workflow can retrieve the current blob after a notification, while a scheduled workflow can list blobs with prefixes and continuation tokens and compare ETags, version IDs, metadata, or stored checkpoints. Idempotency and reconciliation are important because deliveries and polling results may repeat.

How does Martini handle mapping, errors, and duplicate files?

Martini can validate and transform blob content and metadata before sending it to another system or storing a new blob. Workflows can use stable processing keys based on event IDs, blob URLs, ETags, version IDs, or application identifiers, and can apply bounded retries with backoff for transient failures while routing authorization, validation, missing-resource, and poison-file errors separately.

Related Martini documentation

APIs

Workflows

Data

Security

Operations

Integrate Azure Blob Storage with Martini

Use Martini to connect Azure Blob Storage with enterprise applications through secure REST API consumption, Event Grid event handling, scheduled synchronization, file transformation, and reliable workflow orchestration.

EXPLORE MARTINI
BOOK A DEMO