<body><script type="text/javascript"> function setAttributeOnload(object, attribute, val) { if(window.addEventListener) { window.addEventListener('load', function(){ object[attribute] = val; }, false); } else { window.attachEvent('onload', function(){ object[attribute] = val; }); } } </script> <div id="navbar-iframe-container"></div> <script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script> <script type="text/javascript"> gapi.load("gapi.iframes:gapi.iframes.style.bubble", function() { if (gapi.iframes && gapi.iframes.getContext) { gapi.iframes.getContext().openChild({ url: 'https://www.blogger.com/navbar.g?targetBlogID\x3d8211560\x26blogName\x3dTech+Tips,+Tricks+%26+Trivia\x26publishMode\x3dPUBLISH_MODE_BLOGSPOT\x26navbarType\x3dBLUE\x26layoutType\x3dCLASSIC\x26searchRoot\x3dhttp://mvark.blogspot.com/search\x26blogLocale\x3den\x26v\x3d2\x26homepageUrl\x3dhttp://mvark.blogspot.com/\x26vt\x3d-5147029996388199615', where: document.getElementById("navbar-iframe-container"), id: "navbar-iframe" }); } }); </script>

Tech Tips, Tricks & Trivia

by 'Anil' Radhakrishna
An architect's notes, experiments, discoveries and annotated bookmarks.

Search from over a hundred HOW TO articles, Tips and Tricks


Cloud Design Patterns & Anti-Patterns

The below Design patterns  from the Azure Architecture Center are useful for building reliable, scalable, secure applications in the cloud. New design patterns keep getting added so watch out for them on the Design patterns home page. Entire documentation covering each of the patterns can be downloaded as a PDF

Pattern Summary
Ambassador Create helper services that send network requests on behalf of a consumer service or application.
Anti-Corruption Layer Implement a fa├žade or adapter layer between a modern application and a legacy system.
Backends for Frontends Create separate backend services to be consumed by specific frontend applications or interfaces.
Bulkhead Isolate elements of an application into pools so that if one fails, the others will continue to function.
Cache-Aside Load data on demand into a cache from a data store
Circuit Breaker Handle faults that might take a variable amount of time to fix when connecting to a remote service or resource.
CQRS Segregate operations that read data from operations that update data by using separate interfaces.
Compensating Transaction Undo the work performed by a series of steps, which together define an eventually consistent operation.
Competing Consumers Enable multiple concurrent consumers to process messages received on the same messaging channel.
Compute Resource Consolidation Consolidate multiple tasks or operations into a single computational unit
Event Sourcing Use an append-only store to record the full series of events that describe actions taken on data in a domain.
External Configuration Store Move configuration information out of the application deployment package to a centralized location.
Federated Identity Delegate authentication to an external identity provider.
Gatekeeper Protect applications and services by using a dedicated host instance that acts as a broker between clients and the application or service, validates and sanitizes requests, and passes requests and data between them.
Gateway Aggregation Use a gateway to aggregate multiple individual requests into a single request.
Gateway Offloading Offload shared or specialized service functionality to a gateway proxy.
Gateway Routing Route requests to multiple services using a single endpoint.
Health Endpoint Monitoring Implement functional checks in an application that external tools can access through exposed endpoints at regular intervals.
Index Table Create indexes over the fields in data stores that are frequently referenced by queries.
Leader Election Coordinate the actions performed by a collection of collaborating task instances in a distributed application by electing one instance as the leader that assumes responsibility for managing the other instances.
Materialized View Generate prepopulated views over the data in one or more data stores when the data isn't ideally formatted for required query operations.
Pipes and Filters Break down a task that performs complex processing into a series of separate elements that can be reused.
Priority Queue Prioritize requests sent to services so that requests with a higher priority are received and processed more quickly than those with a lower priority.
Queue-Based Load Leveling Use a queue that acts as a buffer between a task and a service that it invokes in order to smooth intermittent heavy loads.
Retry Enable an application to handle anticipated, temporary failures when it tries to connect to a service or network resource by transparently retrying an operation that's previously failed.
Scheduler Agent Supervisor Coordinate a set of actions across a distributed set of services and other remote resources.
Sharding Divide a data store into a set of horizontal partitions or shards.
Sidecar Deploy components of an application into a separate process or container to provide isolation and encapsulation.
Static Content Hosting Deploy static content to a cloud-based storage service that can deliver them directly to the client.
Strangler Incrementally migrate a legacy system by gradually replacing specific pieces of functionality with new applications and services.
Throttling Control the consumption of resources used by an instance of an application, an individual tenant, or an entire service.
Valet Key Use a token or key that provides clients with restricted direct access to a specific resource or service.

The following diagram illustrates how these patterns could be used in a microservices architecture.

Performance antipatterns for cloud applications [PDF]
Antipattern Description
Busy Database Offloading too much processing to a data store.
Busy Front End Moving resource-intensive tasks onto background threads.
Chatty I/O Continually sending many small network requests.
Extraneous Fetching Retrieving more data than is needed, resulting in unnecessary I/O.
Improper Instantiation Repeatedly creating and destroying objects that are designed to be shared and reused.
Monolithic Persistence Using the same data store for data with very different usage patterns.
No Caching Failing to cache data.
Synchronous I/O Blocking the calling thread while I/O completes.

Labels:

Tweet this | Google+ it | Share on FB

« Home | Next »
| Next »
| Next »
| Next »
| Next »
| Next »
| Next »
| Next »
| Next »
| Next »

»

Post a Comment