Tag: API Design

Categories
Platform Migration & Modernization

A Muley Movember: APIs, MuleSoft, & Mustaches

Movember MuleSoft Mustaches

MuleSoft. API Management. Mustaches. I know what you’re thinking. One of these isn’t like the others. What if I told you that growing a mustache has more in common with building complex APIs than you ever thought possible? Movember is upon us once again this year. Movember is a foundation based on growing glorious mustaches to raise awareness and charitable donations every November to support men’s health. To the connection of MuleSoft and mustaches, we’ve gone into detail and laid out 5 categories. Just like the razor, MuleSoft offers the most cutting-edge technology. 

So without further ado, I “mustache” you a question. Are you ready to gain a new perspective into the world of MuleSoft and mustaches?

Transform Your Look

Transformation is at the forefront of building an API as well as growing your mustache. Picture your technology stack and tell us what you see. Are there multiple services that are performing inconsistently, maybe your data is unreliable and dirty, or maybe you have become so bogged down with tech debt that you can’t see the forest through the trees? 

Now, just like before, picture a beard. One that is unruly and scraggly and has no shape or direction. While a mustache is a great way to transform your look, MuleSoft allows us to transform your data. With the help of MuleSoft, data transformations become simple, inconsistent services and endpoints can be rebuilt to perform at lightning speed, and tech debt will begin to clean itself up.

Choose Your Style

Now that you have committed to transformation, a style needs to be chosen. This is an important piece of the puzzle. Are you a Fu Manchu or a handlebars guy? Are you wanting to make a statement with this mustache or do you want it to be more functional? 

The same style question can be asked around your API network. What are you wanting your APIs to do? Are you having issues with lower-level services or would you like to build out multiple layers to handle the flow from client-facing UI to services and back? Maybe you need a complex sync process between multiple systems, which MuleSoft handles very well. Choosing a style is a key piece in the research and planning phase before any targeted progress can be made. Below are some of the more common styles/types of APIs:

      • Open APIs: Allows any developer to access.
      • Partner APIs: Only authorized developers are given access.
      • Internal APIs: Allows for only internal teams to access.
      • Composite APIs: Combines multiple APIs.

Embrace Your Growth Patterns

You may be follicly or technologically challenged. Not everyone can grow a mustache or fully implement MuleSoft to build their API networks on their own. 

While Green Irony is here to help implement all of your MuleSoft needs, we can only offer tips and suggestions with the mustache growth. Slowly growing out your stache or replacing functionality over time in smaller pieces makes the transition and the growth seem less abrupt. 

Mustaches take time to grow. APIs take time to properly build and test. Knowing how you want to grow is pivotal to the overall success of a project. Using a modular API approach gives more flexibility over time. Small pieces over time allow for a seamless approach that allows you to continue building and replacing piece by piece, API by API, until you’ve reached your final form. Just like with a mustache, you don’t want to slap a temporary fake on your lip and call it natural. With this continuous growth process, your outdated systems become more performant and less error-prone without the inherent risk of a big bang approach.

Don’t Neglect Maintenance

So you’ve reached your final form. Production deployments are in the past and systems are connecting and running seamlessly. Or, you’re walking around with the most amazing mustache, comments are flowing in, and you’re even considering changing your name to Mustachio. You may think that it’s time to step back, accept the recognition, and move on, but maintenance is another key piece of the puzzle. You have to be good to the rest of your face and also be good to the rest of your technology stack. 

This is where investing in a quality team/trimmer comes in. Technology is constantly changing, data gets ugly fast, services go down. You must keep trimming, keep modifying, and keep your APIs up to date. This is one of the benefits of moving away from a point-to-point integration approach as it allows you to scale and lower complexity as future requirements arise.

With a mustache, you may notice that your handlebars are going all over the place and need some proper guidance or updates to straighten out. By giving us a much simpler way of updating or replacing APIs, MuleSoft does this by breaking out functionality into different API layers. To maintain a flow, it isn’t necessary to do a large rewrite. If one system needs to be updated or replaced, it’s as simple as building a new API or updating the old one without the need to impact the whole integration. Similar to maintaining your mustache, only the smaller areas will need to be affected.

Be Patient

MuleSoft is built to expedite the time to deliver and build out solutions in a much shorter timeline. Patience is a learned skill, but valuable for both growing a mustache and building complex integrations. Halfway through your MuleSoft project or mustache growth, you may not know what the final product will look like. 

Nobody will fault you for being anxious and concerned about the results. There is a lot of pressure with both of these topics, but with proper planning and following the steps above, you can have confidence in where you’ll end up. 

It’s like that famous quote, “Rome wasn’t built in a day.” The same can be said for growing out an epic stache or building out a successful API network.

As you’re thinking about your next integration project or just starting to see the peach fuzz that will inevitably lead to an award-winning mustache, follow the suggestions above and you will surely find success. 

Please consider contributing to Movember to help raise awareness and support men’s health by growing mustaches, donating, or simply spreading the love. We hope you’ve had a fan-stache-tic time becoming more aware of the similarities between building with MuleSoft and growing a mustache and I hope we didn’t stubble over our words too much. I’d love to stay and chat, but I really “mustache.”

Categories
Digital Transformation Platform Migration & Modernization

Balancing the Scales of API Networks with MuleSoft and CloudHub

Balanced the Scales

In a previous blog post, Aaron Shook broke down how MuleSoft as the platform for your API network can be the key to modernizing the legacy systems driving critical areas of your business. In this post, I want to take that explanation a step further and break down how MuleSoft can be a fulcrum in the balance between your business’s needs and the methods and speed of technology to address those needs.

The Current State of Enterprise Application Networks

There’s always a balancing act that must be maintained when developing enterprise application networks. Often, the balance is focused on size, though not of any one monolithic application or complex microservice. Instead, it’s the size of the business application network.

More and more businesses are relying on building new applications that communicate with older, existing applications developed over the years internally, and from third-party sources. New microservices and APIs are built to bring all of this information together to fulfill an internal business need or build out a more robust offering for their clients. Even more APIs and data flow systems are then required for financial reporting and trends analysis.

The Problems as API Networks Evolve

At some point, an architect or CTO comes to the realization that the evolution of business needs over time has resulted in a number of disparate mainframe systems, web applications, financial systems, CRMs, and so on and so forth. The ability to manage user access, security, and overall maintenance and operations begins to accrue not only technical debt but administrative and project management debt. Even attempting to discuss and agree on a single API design often leads to scattered internal wiki pages, email chains, and often multiple conflicting API design documents.

Now everything slows down – development, the ability to orchestrate multiple layers of APIs, or just trying to find a single source of truth for the company’s API offerings. Progress begins to grind to a halt. As an architect or CTO, one must find a balance that allows for autonomous changes, updates, and new offerings to be made, all the while coordinating the overall flow, access, operation, and maintenance of this living, breathing system.

MuleSoft and their CloudHub iPaaS offering provide that balance, as I’ll detail below.

API Design With MuleSoft

Having a centralized source of truth for an API spec that reflects previous, current, and future versions of an API, and that can be shared amongst departments and units is very important in an enterprise setting.

MuleSoft’s Design View and Exchange allow architects and API designers to develop API specs that are automatically backed by mock implementations and include basic validation declarations of fields and more. These specs can be shared and viewed by those within the company, acting as both documentation and testing platforms before the implementation is ever touched.

On top of that, the implementations can be automatically “discovered” or associated with a particular specification, allowing for multiple concurrent versions to be running, and historical implementations to be viewable by the internal team and others.

As more APIs are added, individual data types can be aggregated into common API data type libraries and shared across APIs. This improves both consistencies of data and models across APIs but also standardizes the languages used by architects, developers, and product managers across the enterprise.

API design provides the foundation from which implementation, changes, and discussions spring. This ethos is ever-present in MuleSoft’s infrastructure and has saved Green Irony a vast amount of time in working with clients and keeping all of product and software development on the same page.

Application Network Security Within MuleSoft’s CloudHub

Security policies, SLA tiers, and access management can all be handled within MuleSoft’s CloudHub platform. It comes built with hooks and supporting modules for Oauth, SAML, basic authentication, client id/secret access, and more. The interesting thing is that policies themselves are associated with a combination of a particular API and consumer – not with the API’s implementation or code. This is important since it allows you to associate a particular policy with many different APIs and manage access across your API network without having to be concerned with how a particular API itself is implemented.

API consumers can request access to a particular API that abides by their associated credentials and CloudHub itself will handle disseminating the request to admins, who themselves have an interface for approving or rejecting individual requests.

On the other side of things, HTTP requests allow for the inclusion of TLS trust and keystores, so there’s no need to sacrifice on the security of outgoing communications.

Banks, insurance companies, and various other financial institutions are using MuleSoft as a bedrock foundation for their application networks. One of the main reasons for that use is MuleSoft’s focus on security. The ease with which we can implement and configure TLS and other security protocols further solidify their focus on protecting data and network traffic.

Developing APIs With MuleSoft’s Anypoint Studio

Since the API design and implementation are entirely separate, the roles of architects, API managers, and implementation developers are kept separate. This separation allows architects to work with product development teams to create, update, and improve the design of an API without impacting developers. Once an API has been designed, developers can import the new or updated API spec into Anypoint Studio and begin working on implementation and changes.

Unlike most frameworks and platforms, MuleSoft’s Anypoint Studio will automatically generate the basic plumbing and connectors for an API based on the spec itself. When an API design is published to Exchange, that connector can then be imported and used by any other API with access.

This aforementioned handling of plumbing gives developers input validation, automatically generates MUnit tests for each endpoint, and provides other assorted freebies.

The ease with which development teams can pull API designs into new projects and update existing projects with changes to the API design cannot be overstated. Additionally, these changes to the API are reflected in the automatically generated connectors by API version, which greatly simplifies updating other APIs and interfacing with them.

There’s also a significant depth to errors, allowing for the continuation of processing if an error is reached, or allowing it to bubble up to the response. All of these errors are wrapped by intuitive namespace/identifier combos that let a developer easily categorize and reclassify errors.

These features all come together to provide developers with more time to focus on the implementation itself. Once development is complete, the API implementation can be deployed to CloudHub where it will be automatically associated with the API specification.

Of course, no API is perfect or complete out of the gate. The spec will change over time. When an API designer updates the specification, developers can import the changes into their Anypoint Studio project, where top-level endpoint updates will be handled automatically.

DevOps for Application Networks With MuleSoft

After development has been completed, it must be deployed, monitored, and maintained. MuleSoft’s CloudHub offering provides for common DevOps needs, from CI/CD, application network monitoring, to VPC management, and more.

Many development teams attempt to wrangle their various technology stacks into some semblance of a CI/CD flow. Understanding this need, MuleSoft has a variety of APIs that can be used to handle deployment, monitoring, and various others needs. Whether it’s Jenkins, Azure, or any other automation setup, the combination of MuleSoft’s maven plugin and REST APIs lets you run and publish test results, as well as deploy full applications, their updates, and associated SLA policies, and more.

Provisioning VPCs, region management, clusters, high availability settings, load balancing – all are actually really easy to do with the Runtime Manager admin interface. It’s also easy to integrate your SLA policy infrastructure and manage those in the API Manager section of CloudHub, and how those APIs are tied to the actual worker applications in Runtime Manager. Runtime Manager admins can also build their dashboards to track their applications, or if already using Splunk, configure their CloudHub workers to interact with and send log data to Splunk.

As applications are running, there will be inevitable issues that need to be tracked down across an application network. Usually, these are associated with individual requests that are failing. MuleSoft comes with a built-in feature called “correlation ID”, that will let external clients communicate with MuleSoft, and especially requests between MuleSoft APIs, to log errors and anything else and have them associated with that particular ID.

As with API design, security, and development, the suite of features presented to DevOps personnel simplifies the provisioning, management, and maintenance of APIs.

Conclusion

There is no single feature in the MuleSoft family that causes it to dominate the API industry. Instead, it’s the culmination of all the helpful features and abilities across every aspect of API network design, development, and implementation.

MuleSoft and CloudHub give enterprise companies a holistic view and insight into all of their APIs on the application network. Everything from having built-in API documentation and source of truth, to full-feature operations support – these are all extremely helpful and useful for businesses trying to get a hold of all of their APIs. Sure, keep the APIs on other systems, but have MuleSoft provide its own tiny API microservice interface to them, and bring them into the fold of everything else in your business.

Everything in IT is a balance. MuleSoft attempts to be a fulcrum in the balance between a business’s needs and the methods and speed of technology to implement them. It goes out of its way to provide a suite of features, all customizable, to remove the boilerplate and solved problems in building and maintaining application networks. This allows developers, business analysts, and operational teams the freedom and time to focus on the actual business problem and not on recreating the wheel around API design, implementation, and management.