Performance is paramount when developing web applications. A slow, unresponsive application results in poor user experience, losing users, and possibly business. For ASP.NET Core developers, there are many techniques and best practices to optimize application performance. Lets explore some of these approaches in this article.

When we talk about performance, the first thing to ask is Where is the issue? Without understanding where the bottlenecks are, we could end up optimizing parts of our application that wont have a significant impact on overall performance.

There are many tools and techniques to identify performance bottlenecks in an ASP.NET Core application:

One of the simplest approaches is to add logging and metrics to your application. You can measure how long operations take and log any issues that occur.

ASP.NET Core supports a logging API that works with a variety of built-in and third-party logging providers. You can configure the built-in logging providers to output logs to the console, debug, and event tracing.

Heres an example of how you can use the ILogger service to log the execution time of a method:

public IActionResult Index(){var watch = Stopwatch.StartNew();

// Code to measure goes here...

watch.Stop();var elapsedMs = watch.ElapsedMilliseconds;_logger.LogInformation("Index method took {ElapsedMilliseconds}ms", elapsedMs);

return View();}}

A more advanced way to identify performance bottlenecks is to use a profiler. A profiler is a tool that monitors the execution of an application, recording things like memory allocation, CPU usage, and other metrics.

There are many profilers available, including:

Application Performance Management (APM) tools go a step further, providing in-depth, real-time insights into an applications performance, availability, and user experience. APM tools can identify performance bottlenecks in real-world scenarios, not just in development and testing.

Asynchronous programming is a way to improve the overall throughput of your application on a single machine. It works by freeing up a thread while waiting for some IO-bound operation (such as a call to an external service or a database) to complete, rather than blocking the thread until the operation is done. When the operation is complete, the framework automatically assigns a thread to continue the execution.

The result is that your application can handle more requests with the same number of threads, as those threads can be used to serve other requests while waiting for IO-bound operations to complete.

ASP.NET Core is built from the ground up to support asynchronous programming. The framework and its underlying I/O libraries are asynchronous to provide maximum performance.

Heres how you might write an asynchronous action in an ASP.NET Core controller:

In this example, GetDataAsync might be making a call to a database or an external service. By awaiting this method, the thread executing this action can be freed up to handle another request.

Heres an example of how you might use async in a service that calls Entity Framework Core:

public MyService(MyDbContext context){_context = context;}

public async Task GetDataAsync(){return await _context.MyData.OrderBy(d => d.Created).FirstOrDefaultAsync();}}

Caching is an effective way to boost the performance of your ASP.NET Core applications. The basic idea is simple: instead of executing a time-consuming operation (like a complex database query) every time you need the result, execute it once, cache the result, and then just retrieve the cached result whenever you need it.

ASP.NET Core provides several built-in ways to cache data:

In-memory caching is the simplest form of caching. It stores data in the memory of the web server. This makes accessing the cached data extremely fast.

In-memory caching in ASP.NET Core stores cache data in the memory of the web server. The data is stored as key-value pairs and can be any object. The access to the in-memory cache is extremely fast, making it an efficient way to store data thats accessed frequently.

One thing to note about in-memory caching is that the cache data is not shared across multiple instances of the application. If you run your application on multiple servers, or if you use a process-per-request model, then the in-memory cache will be separate for each instance or process.

In-memory caching can be an effective way to improve the performance of your application in the following scenarios:

Heres an example of how you might use in-memory caching in an ASP.NET Core controller:

public MyController(IMemoryCache cache){_cache = cache;}

public IActionResult Index(){string cacheEntry;

if (!_cache.TryGetValue("_MyKey", out cacheEntry)) // Look for cache key.{// Key not in cache, so get data.cacheEntry = GetMyData();

// Set cache options.var cacheEntryOptions = new MemoryCacheEntryOptions()// Keep in cache for this time, reset time if accessed..SetSlidingExpiration(TimeSpan.FromMinutes(2));

// Save data in cache._cache.Set("_MyKey", cacheEntry, cacheEntryOptions);}

return View(cacheEntry);}

private string GetMyData(){// Simulating a time-consuming operationThread.Sleep(2000);return "Hello, world!";}}

In this example, the GetMyData method simulates a time-consuming operation. This could be a complex database query, a call to an external service, or any operation that takes time to execute. By caching the result, we avoid the need to execute this operation every time the Index action is called.

Distributed caching involves using a cache thats shared by multiple instances of an application. ASP.NET Core supports several distributed cache stores, including SQL Server, Redis, and NCache.

When using a distributed cache, an instance of your application can read and write data to the cache. Other instances can then read this data from the cache, even if theyre running on different servers.

You should consider using distributed caching in the following scenarios:

When we talk about improving the performance of web applications, one area often overlooked is the size of the HTTP responses. Large responses take longer to transmit over the network, and this latency can have a significant impact on performance, especially for clients with slow network connections.

Response compression is a simple and effective way to reduce the size of HTTP responses, thereby improving the performance of your application. It works by compressing the response data on the server before sending it to the client. The client then decompresses the data before processing it. This process is transparent to the end user.

The most common compression algorithms used for response compression are Gzip and Brotli. They can significantly reduce the size of responses, often by 70% or more.

ASP.NET Core includes middleware for response compression. To enable it, you need to add the middleware to your Startup.ConfigureServices and Startup.Configure methods, like this:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env){app.UseResponseCompression();

// Other middleware...}

By default, the response compression middleware compresses responses for compressible MIME types (like text, JSON, and SVG). You can add additional MIME types if necessary.

You should also configure your server (like IIS, Kestrel, or HTTP.sys) to use dynamic compression. This ensures that your responses are compressed even if youre not using the response compression middleware (for example, for static files).

While response compression can improve performance, there are a few things to keep in mind:

Entity Framework Core (EF Core) is a powerful Object-Relational Mapper (ORM) that simplifies data access in your .NET applications. However, if used without consideration for its performance behavior, you can end up with an inefficient application. Here are some techniques to improve the performance of your applications that use EF Core:

Lazy loading is a concept where the related data is only loaded from the database when its actually needed. On the other hand, Eager loading means that the related data is loaded from the database as part of the initial query.

While lazy loading can seem convenient, it can result in performance issues due to the N+1 problem, where the application executes an additional query for each entity retrieved. This can result in many round-trips to the database, which increases latency.

Eager loading, where you load all the data you need for a particular operation in one query using the Include method, can often result in more efficient database access. Here's an example:

In this example, each Order and its related Customer are loaded in a single query.

When you query data, EF Core automatically tracks changes to that data. This allows you to update the data and persist those changes back to the database. However, this change tracking requires additional memory and CPU time.

If youre retrieving data that you dont need to update, you can use the AsNoTracking method to tell EF Core not to track changes. This can result in significant performance improvements for read-only operations.

EF Core 5.0 and above support batch operations, meaning it can execute multiple Create, Update, and Delete operations in a single round-trip to the database. This can significantly improve performance when modifying multiple entities.

In this example, all the new orders are sent to the database in a single command, rather than one command per order.

Try to filter data at the database level rather than in-memory to reduce the amount of data transferred and memory used. Use LINQ to create a query that the database can execute, rather than filtering the data after its been retrieved.

In this example, only the orders from the last seven days are retrieved from the database.

The Select N+1 issue is a common performance problem where an application executes N additional SQL queries to fetch the same data that could have been retrieved in just 1 query. EF Cores Include and ThenInclude methods can be used to resolve these issues.

This query retrieves all orders, their related Customers, and the Addresses of the Customers in a single query.

When your application needs to interact with a database, it opens a connection to the database, performs the operation, and then closes the connection. Opening and closing database connections are resource-intensive operations and can take a significant amount of time.

Connection pooling is a technique that can help mitigate this overhead. It works by keeping a pool of active database connections. When your application needs to interact with the database, it borrows a connection from the pool, performs the operation, and then returns the connection to the pool. This way, the overhead of opening and closing connections is incurred less frequently.

Connection pooling is automatically handled by the .NET Core data providers. For example, if you are using SQL Server, the SqlConnection object automatically pools connections for you.

When you create a new SqlConnection and call Open, it checks whether there's an available connection in the pool. If there is, it uses that connection. If not, it opens a new connection. When you call Close on the SqlConnection, the connection is returned to the pool, ready to be used again.

You can control the behavior of the connection pool using the connection string. For example, you can set the Max Pool Size and Min Pool Size options to control the size of the pool.

Optimizing the performance of your ASP.NET Core applications can be a challenging task, especially when youre dealing with complex, data-rich applications. However, with the right strategies and tools at your disposal, its a task thats well within your reach.

In this article, weve explored several key strategies for performance optimization, including understanding performance bottlenecks, leveraging asynchronous programming, utilizing different types of caching, compressing responses, optimizing Entity Framework Core usage, and taking advantage of advanced features such as connection pooling and HTTP/2.

The key takeaway here is that performance optimization is not a one-time event, but a continuous process that involves monitoring, analysis, and iterative improvement. Always be on the lookout for potential bottlenecks, and remember that sometimes the smallest changes can have the biggest impact.

Moreover, while we focused on ASP.NET Core, many of these principles and techniques apply to web development in general. So, even if youre working in a different framework or language, dont hesitate to apply these strategies. The ultimate goal of performance optimization is to provide a smooth, seamless experience for your users.

Happy coding, and heres to fast, efficient applications!

Original post:
Turbocharging ASP.NET Core Applications: A Deep Dive into ... - Medium

Opinion All tech grunts know an update from a vendor can be good news, bad news, or both. Fortunately, theres a quick way to tell even before the first sentence of the community blog post that is today's royal proclamation of choice. If the person addressing the community is an engineer, its good news. If marketing, not so much.

Hence the sinking feeling when the renaming of Azure AD to Microsoft Entra ID was revealed to the community (thats you) by a General Marketing Manager. This isnt a dig at marketing or marketing people in general, nor exalting engineering as a higher, purer, more noble calling. Even though it is. Nor that a cartoon penguin as the entire Linux marketing department has done a lot less damage. Even though it has.

The trouble is that people who have to make things work have little interest in marketing, at least as something of immediate interest. If things are changing, people need to hear the hows and whys from those who live that work and if youre doing daily hands-on enterprise IT infrastructure, you want to hear from senior devs, PMs or higher. If you dont get that, the vendor doesnt know or doesnt care what you need, or has to bluff that the incoming change isnt just putting a pile of work on you for its own benefit.

In this case, the story is that the rebranding of Azure AD to Entra makes no difference to anyone, its just a name, man. Which is true if you dont have to update management documents, procedures, licenses, training materials, asset portfolios, and so on. Marketing people dont see this, they see a clean name change.

There are good reasons for new names, when there are new things to be named. There are good reasons for old names, when they refer to important, established ideas. Unfortunately for us, old names also have what marketing people call mindshare. Thats why celebrities get big bucks for smiling at consumer goods - the marketing people know some of that positive mind-share the celeb has will spill over. Its a shortcut to our psyches. Enterprise IT doesnt really do influencers, which saves Linus from hawking manscaping razors, but we do have big name technologies.

Thats why, when Microsoft needed to put identity management into the cloud, it decided to retain the Active Directory name in Azure AD, despite it being a bad fit and the two products doing quite different things. The cloud is not your on-prem collection of LED flashers. Active Directory hails from 2000; it knows about PCs and group policies and physical servers. Azure knows about the virtualised landscape of cloud resources.

The arrival of Azure ID management would have been a great time for a new name, too, that reflected the fundamental change in philosophy. Azure AD could not replace Active Directory, and Active Directory could not manage cloud services.

Yet the pull of the old was too strong to resist. Heck, this was in the days when Microsofts cloud was still called Windows Azure a legacy of it being born in 2010 under Steve Ballmers watch. It was only itself renamed to Microsoft Azure less than 10 years ago. Upwards compatibility had to be implied in name even if lacking in fact.

It was lacking. The two identity managers couldnt even share identity management at the simplest level. Users had to use both, which of course they did? Then they had to have two separate IDs, which would not be a problem. It just means that if you have a password change policy that users will have to do this twice (and they could of course choose the same password for both). Tell me youve never managed users without saying youve never managed users.

But now Azure AD has been around long enough to be bedded in, marketing no longer sees Windows as a selling point. Time to rename it and make it just part of the Entra brand of things that can be licensed in so many creative and lucrative ways. Let the rest of the industry pay for the bulk of the rebranding consequences. Marathon to Snickers, Windscale atomic disaster site to Sellafield. Does it matter?

Much more than many might think. In most of the world, the names we give to things are just that names. They dont form part of the thing itself. You can recap a vintage IBM PC, and it doesnt matter that capacitors were once called condensers, or that IBM called printed circuit boards planars. Both work just fine if you call them Freds and Cynthias. But in the world of code and data, or objects and procedures, or APIs and spaces, the names are an intrinsic feature. If youre building something new, you name a lot of its internals after the whole thing. Your APIs will reference the name,, your internal code structure will identify themselves thus, and other software, tools and automation will use that name. Its part of the hierarchy by which everything works.

So when, for marketing purposes, the package changes its name, there are just two choices. Rename all those references, which has the potential for a rolling fustercluck that scales faster than an Oracle invoice after an audit, or leave well alone and watch the code fossilize, like a forgotten kingdom known only for the placenames it leaves behind. Its not that this is impossible to manage, but youd think a world where keeping old systems alive is increasingly difficult, IT vendors would have some idea of the responsibility they have for future, that they understood something about the unique nature of the industry theyre part of.

Naw. Only engineers worry about those sorts of horizons. Theres a saying that marketing is the price a company pays for being boring; in IT, we all get to chip in too.

See more here:
Goodbye Azure AD, Entra the drag on your time and money - The Register

The growth and success of computing has been a story about creating ways to make cross-platform connections.

The rise of hypertext markup language, or HTML, as a common language for web page creation in the 1990s allowed a broad audience to fuel internet growth. Bluetooth emerged in the early 2000s as a short-range wireless standard that enabled cross-device communication.

This same story is now being written in the cloud world, specifically the supercloud, a hybrid and multicloud abstraction layer that sits above and across hyperscale infrastructure. As theCUBE, SiliconANGLE Medias livestreaming studio, prepares to hold its Supercloud 3 eventon July 18, the landscape is continuing to evolve as a growing number of major companies are taking steps to build cross-cloud services. This is being driven by customers who prefer having multiple clouds yet are frustrated by the challenge of having to manage them.

Its too complicated to really take advantage of multicloud to the degree theyd like without engaging outside talent, said Dave Vellante, industry analyst for theCUBE, SilconANGLE Medias livestreaming studio, in a recent Breaking Analysis post. Thats an opportunity, thats supercloud a mesh of multiple clouds that are interconnected and managed as a single entity. Cross-cloud simplification is needed and will deliver business benefits in terms of getting more done with less, faster and more securely.

The technology driving supercloud has advanced since theCUBE held its inauguralSupercloud event last August. Soon after the event, VMware Inc. unveiled new solutions for its Cross-Cloud Services portfolio, including Cloud Foundation+ for managing and operating full stack hyperconverged infrastructure in data centers and two projects designed to provide multicloud networking and advanced cross-platform security controls.

Cloudflare Inc. has built the equivalent of a distributed supercomputer that connects multiple clouds and can allocate resources at a large scale. In June, the company announced an agreement with Databricks Inc. to more simply share and collaborate on live data across clouds.

The technology that will make up a supercloud is getting better constantly: AIOps, cross-cloud security, cross-cloud data management, etc., said David Linthicum, chief cloud strategy officer of Deloitte Consulting, in an interview for this story. Suitable investments have been made in that tech over the past year.

Where does this leave the major cloud providers such as Amazon Web Services Inc., Microsoft Corp. and Google LLC? The hyperscalers have provided the foundation on which superclouds were built, such as in the case of AWS serving as the host platform for Snowflake Inc.

There have been signs of interest among hyperscalers in providing cross-cloud services, such as Microsofts continued partnership with Oracle Corp. to deliver streamlined access to Oracle databases for Azure customers via Oracle Cloud Infrastructure. In late May, Google LLC. announced Cross-Cloud Interconnect services through Google Cloud.

Yet there is a growing belief among some analysts that the hyperscalers will ultimately have to do more.

The hyperscalers should be more focused on this space, in my opinion, Linthicum said. I think it is an opportunity for them, as well as a moment to invest in existing supercloud players, which are smaller companies.

Some of those smaller companies are working on solutions for architecting at the edge. This emerging field of edge architecture for supercloud represents a growth opportunity for dealing with the volume and scale of connected devices and decisions around where data will be processed.

Its no longer a uniform set of compute and storage resources that are available at your disposal, said Priya Rajagopal, director of product management at the database company Couchbase Inc., in an interview with theCUBE Youve got a variety of IoT devices. Youve got mobile devices, different processing capabilities, different storage capabilities. When it comes to edge data centers, its not uniform in terms of what services are available.

Couchbases NoSQL database technology powers complex business applications and its Capella offering provides a cloud-hosted database as a service that is available on AWS, Microsoft Azure and Google Cloud.Couchbases technology offers an intriguing view of how supercloud can help solve connectivity issues at the edge. Data sync at the edge is a challenge when low network connectivity can be common in remote locations.

Couchbase solves this problem through the use of global load balancers that can redirect traffic in a connectivity failure. Applications continue to run and then are automatically synced to backend servers when connectivity resumes.

I think once you start going from the public cloud, the clouds there scale, said Muddu Sudhakar, co-founder and CEO of Aisera Inc., in an interview on theCUBE. The lack of computer function will kick in. I think everything should become asynchronous. I think as long as algorithms can take that into the edge, I think that superclouds can really bridge between the public cloud to the edge.

While supercloud offers promise for solving the nettlesome problem of processing data at the edge, its potential for the delivery of key cross-cloud services, such as AI and security, remains a central focus for the enterprise.

Vellante has termed the evolving enterprise model as an AI-powered hybrid-multi-supercloud, and the role of artificial intelligence cannot be underestimated. The rise of ChatGPT, an OpenAI LP tool for generating articulate, human-like responses to a wide range of queries, has opened the gates for AI adoption on a massive scale.

Where the supercloud converges with ChatGPT and other AI tools will be in the delivery of services in an abstraction layer that deconstructs complexity, according to Howie Xu, former vice president of machine learning and artificial intelligence at Zscaler Inc. and now with Palo Alto Networks Inc. In order for me as a developer to create applications, I have so many things to worry about, and thats complexity, said Xu, in an interview on theCUBE. But with ChatGPT, with the AI, I dont have to worry about it. Those kinds of details will be taken care of by the underlying layer.

As businesses increasingly put data foundations in place to take full advantage of hybrid multicloud environments, management of this infrastructure and the massive amount of information required by AI tools will create further demand for cross-cloud connectivity.

The growth of AI will drive more use cases that span clouds, Linthicum said. These AI systems need vast amounts of data to work well, and that data will be in any number of cloud platforms and needs to be accessed. Since the relocation of data is typically not cost viable, the data will be leveraged where it exists and thus the need to manage data integration at the supercloud level. This will drive tremendous growth.

Perhaps one of the most difficult services to deliver in a supercloud model is security. This is because the cloud is complex and there is a lack of visibility for workloads operating in software containers that drive modern applications.

In theCUBEs Supercloud 2 event in January, Piyush Sharma, founder of Accurics (acquired by Tenable Inc.), called for common standards that would help implement consistent security practices across cloud models.

I think we need a consortium, we need a framework that defines that if you really want to operate in supercloud, Sharma said. Otherwise, security is going everywhere. [SecOps] will have to fix everything, find everything its not going to be possible.

Not long after Sharma appeared on theCUBE, there was movement toward implementing the common framework he described. AWS, Splunk Inc. and over a dozen other firms announced the launch of the Open Cybersecurity Schema Framework.

The goal of OCSF is to streamline the processing of data after cyberattacks and reduce the amount of manual work required to share information between security tools. In November, Cribl Inc. announced its support for OCSF and the use of Cribl Stream by AWS customers for converting data from any source into the OCSF format.

Security is challenging because of the complexity of the security models that run within each native cloud provider, Linthicum said. You somehow need to figure out how to abstract and automate those services so they can function with some cross-cloud commonality. This needs to be a focus for the supercloud tech providers, even the hyperscalers.

Over the past year, supercloud has moved beyond being merely a platform built by others successfully on the hyperscalers into a new phase where enterprises are clamoring for unified cross-cloud services and companies are lining up to provide them. With a nod to the author Norman Mailer, supercloud has come to the supermarket.

TheCUBEis an important partner to the industry. You guys really are a part of our events and we really appreciate you coming and I know people appreciate thecontent you create as well Andy Jassy

THANK YOU

Originally posted here:
Supercloud comes to the supermarket: How growing interest in ... - SiliconANGLE News

Munich Terminal 1 Airline Club, a group of carriers operating from terminal 1 in Munich, Germanys second-largest airport, has adopted Amadeus cloud technology to simplify and improve the passenger service operations of its members.

The club is a group of airlines responsible for selecting and managing shared technology at key service points like check-in and boarding.

Providing IT infrastructure that multiple airlines share at the airport can be complex. Previously, multiple costly network links needed to be maintained between each airline and Munich airport, with computing happening on hard-to-maintain servers located at the terminal.

Passenger service agents connected to these local servers with energy-intensive traditional PCs in order to access multiple airline systems.

With the objective of improving the efficiency of this shared infrastructure, Munich T1 Airline Club has now migrated 330 workstations at check-in counters, boarding gates and lost & found desks to the Amadeus Airport Cloud Use Service (ACUS).

The move eliminates the need for local servers and costly legacy networks. Instead, agents can now access any Departure Control System they need using energy-efficient thin client machines, which connect to the cloud using a single cost-effective internet link.

Patrik Toepfner, Chairman of the Munich T1 Airline Club, Munich Airport said: Weve selected Amadeus as our partner for shared infrastructure because its cloud model greatly simplifies the technology we use at the airport.

We are confident this choice will streamline our operations and improve the overall travel experience for passengers at Munich terminal 1.

Yannick Beunardeau, SVP Airport & Airline Operations EMEA, Amadeus added: A growing number of airports and airlines are recognizing the simplicity of accessing passenger service technology from the cloud.

With this modern approach, agents can focus on delivering the best possible service to passengers using any airline system they need through an internet browser.

Were seeing specialist software at airports become more like the simple consumer applications we use in our personal lives and that can only be a good thing.

See the original post:
Airlines at Munich Airport streamline IT with Amadeus cloud ... - Airline Routes & Ground Services

Akamai continued to advance its cloud ambitions this week, with the announcement of new services and cloud locations around the world.

For much of its history, Akamai was primarily known as a content delivery network (CDN) and security service provider. That changed in 2022, when Akamai acquired alternative cloud provider Linode in a $900 million deal. Earlier this year, Akamai outlined its Connected Cloud strategy, which ties together its CDN and edge network assets with its Linode public cloud footprint, an approach designed to create more value for end users.

Related: 5 Cloud Cost Optimization Best Practices You Might Have Missed

With this week's news, Akamai is delivering on some of its Connected Cloud promises by expanding its public cloud sites and services. The new services include premium cloud instances, more object storage capacity, and a new global load balancer. The five new sites are located in Paris; Washington, D.C.; Chicago; Seattle; and Chennai, India.

Hillary Wilmoth, director of product marketing, cloud computing, at Akamai, told ITPro Today that the locations of new sites were selected based on customer feedback and to bring computing services closer to users as part of the Akamai Connected Cloud strategy.

Related: 6 Tips for Controlling Your Cloud Costs in a Recession

"These sites start to marry the cloud computing of Linode with the CDN scale of Akamai," she said.

A primary element of any public service is some form of virtual compute instances. As part of the new updates, Akamai introduced what the company refers to as "premium" instances.

Premium instances guarantee compute resources, a minimum processor model (currently an AMD EPYC 7713), and easy upgrades to newer hardware as it becomes available, Wilmoth explained.

"Premium CPU instances enable businesses to design their applications and infrastructure around a consistent bare minimum performance spec," she said.

Storage capacity is also getting a big boost. Akamai is now expanding its object storage bucket size to a maximum of 1 billion objects and 1 petabyte of data per storage bucket, representing a doubling of prior limits.

The other new piece of Akamai's public cloud service is the Akamai Global Load Balancer. The new load balancer expands on capabilities that Linode had been offering with its NodeBalancers service. Linode NodeBalancers direct traffic from the public internet to instances within the same data center, Wilmoth said. For example, a NodeBalancer can distribute traffic evenly between a cluster of web servers.

In contrast, she said the Akamai Global Load Balancer provides load balancing based on performance, weight, and content (HTTP/S headers, query strings, etc.) while being able to support multi-region or multicloud deployments, independent of Akamai.

The new sites and services are all part of the momentum that Akamai has been building since its acquisition of Linode.

Wilmoth said the vision is to build a cloud for the future that challenges the existing centralized design of current cloud architectures. Looking forward, she said to expect the Akamai Connected Cloud to include additional core sites as well as distributed sites designed to bring powerful compute resources to hard-to-reach locations. Akamai is also planning to expand capabilities and capacity for object storage, including multi-cluster support for horizontal scaling and automated bucket placement to optimize resource utilization.

"We'll continue to support open source, cloud-native, and partner integrations in pursuit of portable cloud workloads that align with best practices for multicloud," Wilmoth said.

About the author

Here is the original post:
Akamai Grows Connected Cloud Effort with New Sites and Services - ITPro Today