Estimated reading time: 8 minutes
Salesforce, while a powerful platform on its own, often needs to interact with external systems to create a unified and comprehensive business solution. This integration can be achieved through various methods, with Events, Microservices, and APIs being prominent approaches. Let’s explore each of these in detail with practical use cases.
1. Integration using Events
Event-driven integration involves Salesforce publishing or subscribing to events that occur within or outside the platform. This approach promotes loose coupling and enables real-time or near real-time data synchronization and process automation.
Salesforce as an Event Publisher
Salesforce can publish events when specific actions occur within the platform.
- Platform Events: Custom events defined within Salesforce that can be published and subscribed to by Apex triggers, flows, and external applications (using CometD or Pub/Sub API).
- Change Data Capture (CDC): Automatically publishes events when Salesforce records are created, updated, deleted, or undeleted. External systems can subscribe to these events to maintain near real-time data synchronization.
Use Case: Real-time Inventory Synchronization
Integrate Salesforce with an external inventory management system to update product availability in real-time when a sale occurs in Salesforce.
- Method: Platform Events
- 1. Define a Platform Event in Salesforce named
OrderProcessed__ewith relevant fields likeProductId__candQuantity__c. - 2. In an Apex trigger that fires after an Order is created and its status is ‘Confirmed’, publish an
OrderProcessed__eevent with the details of the ordered products. - 3. An external inventory management system subscribes to the
OrderProcessed__eevent using the Salesforce Pub/Sub API (or CometD for older implementations). - 4. Upon receiving the event, the inventory system updates its stock levels for the corresponding
ProductId__cby decrementing theQuantity__c.
Use Case: Updating Customer Data in External CRM
Keep customer contact information synchronized between Salesforce and an external legacy CRM system.
- Method: Change Data Capture (CDC)
- 1. Enable Change Data Capture for the
Contactobject in Salesforce. - 2. An external integration service subscribes to the
ContactChangeEventstream using the Salesforce Pub/Sub API. - 3. When a Contact record is created or updated in Salesforce, a
ContactChangeEventis published. - 4. The integration service receives the event, extracts the changed fields and their new values, and updates the corresponding Contact record in the external CRM system.
Salesforce as an Event Subscriber
Salesforce can also subscribe to events published by external systems.
- Platform Event Subscriptions (External): External systems can publish Platform Events to Salesforce, which can then be processed by Apex triggers, flows, or the Salesforce Functions.
- Integration Platforms: Tools like MuleSoft, Dell Boomi, and others can listen to events from external systems and trigger actions within Salesforce via APIs.
Use Case: Processing External Support Tickets
Automatically create Salesforce Cases from support tickets created in an external support portal.
- Method: Platform Event Subscriptions (External)
- 1. Define a Platform Event in Salesforce named
SupportTicket__ewith fields likeTicketId__c,Subject__c, andDescription__c. - 2. When a new support ticket is created in the external portal, the portal publishes a
SupportTicket__eevent to Salesforce using the Salesforce Pub/Sub API. - 3. An Apex trigger subscribes to the
SupportTicket__eevent. - 4. The trigger receives the event data and creates a new
Caserecord in Salesforce, populating fields from the event data.
2. Integration using Microservices
Microservices are small, independent, and loosely coupled services that communicate with each other over a network. Integrating Salesforce with microservices allows you to offload complex business logic or integrate with specialized external functionalities without tightly coupling them to the Salesforce platform.
Salesforce Calling Microservices
Salesforce can make synchronous or asynchronous calls to external microservices via HTTP REST or SOAP APIs.
- Apex Callouts: Apex provides built-in classes (
Http,HttpRequest,HttpResponse) to make HTTP requests to external endpoints. For asynchronous calls,@future(callout=true)methods can be used. - Salesforce Functions: Serverless functions written in Node.js or Java that can be invoked from Apex triggers or flows to perform complex operations externally.
Use Case: Address Verification
Verify customer-provided addresses against an external address verification microservice before saving them in Salesforce.
- Method: Apex Callouts
- 1. When a new Account or Contact record is about to be saved, an Apex trigger (
before insertorbefore update) is triggered. - 2. The trigger makes a synchronous HTTP POST callout to the external address verification microservice, sending the address details in the request body (e.g., in JSON format).
- 3. The microservice processes the address and returns a standardized and verified address in the response.
- 4. The Apex trigger parses the response and updates the address fields on the Salesforce record with the verified details. If the verification fails, an error can be displayed to the user.
Use Case: Complex Discount Calculation
Offload complex discount calculation logic to an external microservice for better performance and maintainability.
- Method: Salesforce Functions
- 1. A Salesforce Function is developed to implement the complex discount calculation logic, potentially using external libraries or data sources.
- 2. When an Opportunity Line Item is created or updated, an Apex trigger invokes the Salesforce Function, passing relevant details like product ID, quantity, and customer tier.
- 3. The Salesforce Function executes the discount calculation and returns the calculated discount amount to Salesforce.
- 4. The Apex trigger updates the
Discount__cfield on the Opportunity Line Item with the value returned by the Function.
Microservices Calling Salesforce
External microservices can also interact with Salesforce to retrieve or manipulate data.
- Salesforce REST API: Provides a comprehensive set of RESTful web services to access Salesforce data and functionality. Microservices can use OAuth 2.0 for secure authentication.
- Salesforce SOAP API: A more traditional SOAP-based API, still available for certain use cases.
Use Case: External Reporting Dashboard
A microservice powers an external reporting dashboard that needs to display real-time sales data from Salesforce.
- Method: Salesforce REST API
- 1. The microservice is configured with OAuth 2.0 credentials to securely authenticate with the Salesforce organization.
- 2. The microservice periodically makes calls to the Salesforce REST API, querying the
Opportunityobject for relevant fields likeAmount,StageName, andCloseDateusing SOQL queries. - 3. Salesforce returns the requested data in JSON format.
- 4. The microservice processes the data and updates the visualizations on the external reporting dashboard.
3. Integration using APIs (Directly)
Direct API integration involves establishing communication between Salesforce and external systems using their respective APIs without necessarily adhering to a strict event-driven or microservices architecture.
Salesforce Calling External APIs
Similar to calling microservices, Salesforce can directly interact with external APIs.
- Apex Callouts: Used for making HTTP requests to various external API endpoints (REST or SOAP).
Use Case: Payment Processing
Integrate Salesforce with a third-party payment gateway to process customer payments.
- Method: Apex Callouts
- 1. When an Order in Salesforce reaches a ‘Payment Due’ status, an Apex trigger is triggered.
- 2. The trigger gathers the necessary payment information (amount, currency, customer details) and makes an HTTP POST callout to the payment gateway’s API endpoint.
- 3. The payment gateway processes the payment and returns a response indicating success or failure.
- 4. The Apex trigger parses the response and updates the payment status and related fields on the Salesforce Order accordingly.
External Systems Calling Salesforce APIs
External applications can directly interact with Salesforce APIs.
- Salesforce REST API: For accessing and manipulating Salesforce data using standard HTTP methods.
- Salesforce SOAP API: For more complex integrations requiring SOAP-based messaging.
- Bulk API: Optimized for loading or extracting large volumes of data.
- Metadata API: For managing Salesforce metadata (e.g., deploying code, creating objects).
Use Case: Mobile Application Integration
A mobile application needs to retrieve customer account details from Salesforce.
- Method: Salesforce REST API
- 1. The mobile application authenticates with the Salesforce REST API using OAuth 2.0.
- 2. The application makes HTTP GET requests to the Salesforce REST API endpoints (e.g.,
/services/data/vXX.0/sobjects/Account/{accountId}) to retrieve specific account details. - 3. Salesforce returns the account data in JSON format, which the mobile application then displays to the user.
Choosing the Right Integration Approach
The best integration approach depends on several factors:
- Real-time vs. Batch Requirements: Events are suitable for near real-time synchronization, while APIs can be used for both. Batch API is ideal for large data volumes.
- Complexity of Logic: Microservices are beneficial for offloading complex business rules.
- Coupling: Events promote loose coupling, making systems more independent.
- Scalability and Maintainability: Microservices can enhance scalability and maintainability.
- Security: Each approach requires careful consideration of authentication and authorization.
- Existing Infrastructure: The existing architecture of the external system will influence the choice.
- Development Effort: The complexity of implementation varies for each approach.
In many real-world scenarios, a combination of these approaches might be used to achieve a robust and flexible integration solution.
Conclusion
Integrating Salesforce with the external world is crucial for extending its capabilities and creating seamless business processes. Events, Microservices, and APIs each offer distinct advantages and use cases. By carefully considering your integration requirements and the characteristics of each approach, you can design and implement effective solutions that connect Salesforce with the broader ecosystem of your enterprise.
Leave a Reply