Top10 Point to Point (P2P) Integration Pitfalls
Upcoming SlideShare
Loading in...5
×
 

Top10 Point to Point (P2P) Integration Pitfalls

on

  • 1,564 views

In order to tackle cloud integration successfully, we need to move beyond point to point integration and avoid repeating the same mistakes. This session will go through the top 10 pitfalls of P2P ...

In order to tackle cloud integration successfully, we need to move beyond point to point integration and avoid repeating the same mistakes. This session will go through the top 10 pitfalls of P2P integration to avoid repeating in the cloud, including, building vs. buying, quick fire integrations, embedding integrations in your application, creating dependencies between applications, assuming everything always works, using independent consultants and the dangers of black box solutions, among others.

Statistics

Views

Total Views
1,564
Views on SlideShare
1,564
Embed Views
0

Actions

Likes
3
Downloads
22
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • Creator of the Mule project: first open source ESBFounder the company behind Mule and its family of productsSit firmly in the love marmite campStarted my career working in banks, telco and insuranceI have always been a “plumber” 14 years experience hooking stuff togetherUltimately I’m a geek that likes to tinker with softwareHuge lego fan, obsessed as a kid. Family guy cracks me up – my wife does notget either one
  • Let’s say you need to integrate two systems quickly and hire a developer to work on the project over a couple of days. You notice an improvement in business efficiency and see an opportunity to integrate additional systems. You hire the same developer and expect the same quickfire integrations, but the complexity of the project has increased exponentially. The takeaway? It’s always a good idea to approach integration systematically and establish a plan up front, rather than integrate your systems in an ad hoc P2P fashion
  • Although it might be tempting to embed P2P integrations in your web application, you should be cautious about this approach. It may be fine for really simple integrations, but over time, your integration logic becomes scattered in different web apps. Instead, you should think of integration as a separate tier of your application architecture and centralize this logic.
  • When you integrate applications in a P2P fashion, you create a dependency between them. For instance, let’s say you’ve integrated App A and App B. When App A is modified or updated, you will need to change the integration that connects it to App B. You also need to re-test the integration to make sure it works properly. If you add App C to the mix, your workload can increase exponentially.
  • Credit: http://www.redbubble.com/people/jggrant/art/5046234-happy-pathOne of the consistently recurring mistakes of doing quick P2P integrations is assuming that things will not break. The reality is that integrations don’t always work as planned. As you integrate systems, you need to design for errors and establish a course of action for troubleshooting different kinds of errors. Error handling is particularly troublesome when integrating SaaS applications because you have limited visibility and control over the changes that SaaS vendors make to them.
  • Many companies are not staffed with developers who have enough integration expertise and hire consultants to resolve their integration issues. The problem with this approach is that you often have limited visibility into whatever the consultant delivers. If you need to make changes you typically need to work with the same consultant, which is not always possible.
  • As your P2P integration architecture grows in size and complexity, its chances of becoming a single point of failure in your entire network increase as well. Minimizing the potential for single points of failure should be a priority when it comes to integration, but the lack of decoupling in a P2P approach makes it hard to eliminate bottlenecks in your system.
  • Custom built P2P solutions are usually black box in nature. In other words, they lack reporting capabilities that tell you what is happening between systems. This makes it very hard to debug problems, measure performance or find out if things are working properly.
  • Quick P2P integrations are relatively manageable when you have 2 or 3 systems to connect, but when you start adding other systems, your architecture quickly becomes a complicated mess. And because no two P2P integrations are exactly the same, managing your integrations becomes a major pain. If you invest in doing some design work up front, however, this will save you from having to throw away a tangled P2P architecture and starting from scratch to find a new solution under pressure. If you have a well thought out design and a simple architecture, you can reduce the management burdens and costs associated with integration.

Top10 Point to Point (P2P) Integration Pitfalls Top10 Point to Point (P2P) Integration Pitfalls Presentation Transcript

  • P2P Integration Pitfalls to Avoid in the Cloud Ross Mason@rossmason, @mulejockey
  • About Me
  • 1. Build versus Buy
  • 2. Quick fire Integration
  • 3. Embedding integration in your application
  • 4. Creating dependencies between applications
  • 5. Taking the Happy Path
  • 6. It worked yesterday
  • 7. Using independent consultants
  • 8. Creating single points of failure
  • 9. No visibility or Control
  • 10. Creating a Monster
  • Avoiding the Pitfalls
  • Integration PaaS
  • Summary1. Buy don’t build2. Use a platform3. Separate integration layer4. Loose Coupling is good5. Avoid the happy path, build for failure6. Need Integration you can test7. take ownership or work with a vendor8. Use a platform that scales9. You need to be able to see what’s going on10. P2P integration always turns into a monster
  • Questions?• iON free account : http://mulesoft.com/ion• Twitter: @rossmason, @mulejockey• Blog: http://blogs.mulesoft.org• Company: http://mulesoft.com (we’re hiring)