orignal address:How edge functions move your back end close to your front end (opens new window)

Serverless functions have made computing seamless and fast. but for worldwide audiences, you need to get closer to your user to overcome latency.

Cloud computing (opens new window) made it way easier for developers to make websites and apps without having to worry about managing their own hardware servers. Serverless computing (opens new window) is a new and cost-effective way that lets developers focus on code, but it can add a delay because of dynamic allocation of resources (cold starts (opens new window)) and the distance between end-users and data centers. Edge computing (opens new window) solves this problem by bringing the servers closer to the users through a distributed network of smaller server clusters, making everything faster for apps including real-time and IoT (Internet of things) applications.

Edge computing brings computation power and data storage closer to the end user, resulting in faster processing and response times. The concept of edge computing is not new; it has been used for many years in manufacturing (opens new window), transportation (opens new window), and oil and gas industries (opens new window) to process data locally and reduce dependence on centralized servers. It gained more attention as some cloud providers such as Amazon Web Services (AWS) (opens new window), Microsoft Azure (opens new window), Google Cloud (opens new window) and others, have introduced edge functions. As a result it is now possible for hobby developers to take advantage of edge computing using edge functions.

One of the key ways to take advantage of edge computing is through the use of edge functions. In this article, we’ll dive deep into the world of edge functions, exploring how they can be used to unlock the full potential of edge computing.

Edge functions

Edge functions are small, lightweight pieces of code that can be deployed at the edge of the network to perform specific tasks or functions—serverless functions deployed on the edge (opens new window). They can be used anywhere to process data with low latency or trigger actions based on specific events or conditions. They allow for faster processing times, reduced latency, and improved reliability. Edge functions operate similar to a content delivery network (opens new window) (CDN), but they are able to run dynamic code rather than just static hosting.

Many cloud providers support edge functions in most programming languages, including JavaScript, TypeScript, Python, Java, Go, and PowerShell. However, the introduction of edge functions is not limited to cloud providers; many companies are developing and deploying their own edge functions to meet the specific needs of their industries. Each cloud provider has their own unique way of handling edge functions, so check out their documentation to learn how to take full advantage of your specific provider.

In the next sections, I’ll dive into some of the most common ways edge functions are being implemented in the software development and IoT industries, specifically with an emphasis on utilizing Netlify’s edge functions (opens new window) in JavaScript.

Serving static and localized content

Edge functions make it easy to serve up content like static files, HTML, and images using JavaScript. All you have to do is create a direct HTTP response (opens new window) from the edge function. In the example below, the edge function returns an HTTP text/html response for serving a static HTML page.

export default async (Request, Context) => {
	// render the page generated using JavaScript
	const html = generateHTML()

	// send our response
	return new Response(html, {
		headers: { 'content-type': 'text/html' },
	})
}

When you use edge functions, they’re deployed on the edge network, meaning the data you’re viewing comes from a server close to you. You can access the user’s approximate location from the geolocation data of the edge function. This is a great way to serve up localized content, like a translated version of your webpage, to the user. The following example uses the geolocation API to serve localized weather forecasts based on the location of the user.

export default async (request, context) => {
	// Retrieve geolocation data from context object
	const countryCode = context.geo?.country?.code || 'US'
	const countryName = context.geo?.country?.name || 'United States'

	// retrieve weather data from the API
	const weather = await getWeatherForecast(countryCode)

	return new Response(`The weather in ${countryName} is: ${weather}`, {
		headers: { 'content-type': 'text/html' },
	})
}

Serverless backend

Edge functions are great for building faster and more efficient serverless backend systems or API gateways that handle network requests. For instance, you can handle things like authentication, managing cookies, and A/B testing, which allows your main application to focus on providing a better user experience.

export default async (request, context) => {
	// Retrieve user data from request object
	const { email, password } = request.body
	// do the authentication
	await authenticateTheUser()
	return Response.json({ message: 'User authenticated', status: 'success' })
}

Many cloud providers let you use Node.js (or its successor, Deno) functions to create your serverless backend, but it’s important to note that the functionality you have access to is limited. Most providers have their own APIs for common use cases, like geolocation.

Real-time data processing and analytics

Edge computing allows you to process data in real time by a server closer to the source of the data. Edge functions are really efficient when it comes to real-time data processing because of low latency and faster processing times. This has a wide range of applications, particularly in the IoT field. For example, you can use edge functions to analyze security video footage as it’s being captured.

export default async (request, context) => {
	// Get the video stream from the request object
	const video_stream = request.body

	// Perform video processing
	const result = doSomethingWithData(video_stream)

	// Return the response
	return Response.json({
		statusCode: 200,
		body: JSON.stringify({
			result: result,
		}),
	})
}

Another great use case for edge functions is data analytics and security reinforcement. With the fetch API provided by Netlify, you can retrieve data from remote sources within the function itself, meaning you can process data and get insights in real time.

export default async (request, context) => {
	// Retrieve request data
	const source = new URL(Request.body.source)
	const data = await fetch(source)

	// Perform analysis on the data
	const result = doSomeDataAnalytics(data)

	// Return success response
	return Response.json({
		statusCode: 200,
		result: result,
	})
}

Process automation

Edge functions are a powerful tool for automating processes in the industrial and manufacturing industry as they provide faster and more reliable automation of processes. They can be used for various applications such as quality control, maintenance, and automated decision-making. For instance, you can use the below edge function to keep an eye on inventory levels and send out alerts via email when stock is running low.

export default async (request, context) => {
	// Retrieve inventory data from database
	const inventoryData = await retrieveInventoryData()

	// Loop through inventory data and check for low stock levels
	for (const item of inventoryData) {
		if (item.quantity < item.reorderThreshold) {
			// Send reorder alert email
			sendEmail(item.name, item.quantity)
		}
	}

	// Return success response
	return Response.json({
		statusCode: 200,
		body: 'Reorder alerts sent successfully',
	})
}

While these are just a few examples, the possibilities are endless when it comes to utilizing edge functions for faster and more efficient processing.

The drawbacks of using edge functions

Just like any other technologies, edge computing and edge functions have their downsides, no matter how awesome they are for fast processing. Before you start using edge functions for your next project, here are a few things to keep in mind:

• Remote data source: A centralized database increases latency, complexity, and security concerns. If you need to fetch data from the database, the distance between the edge server and the database can slow down data retrieval and increase latency. In these cases, it might be more beneficial to opt for distributed database solutions such as AWS DynamoDB Global Table (opens new window) and Azure Cosmos DB Global Distribution (opens new window), which replicate data to multiple regions, along with edge functions. Caching data locally at the edge can help to minimize the delay reducing the number of requests to the centralized database.
• Code and time limits: Edge functions are similar to CDN networks where identical pieces of code are deployed in different locations. So, the code size is limited based on the cloud provider. They’re not ideal for larger computational models or longer requests with response times limited to a few milliseconds.
• Vendor lock-in: Cloud providers have their own way of doing things regarding edge functions. If you switch to a different provider, you’ll probably have to rewrite your code to fit their way of handling things.
• Some security concerns: As edge computing and edge functions rely on a distributed network of servers, the number of potential attack vectors (opens new window) increases. This makes it more challenging to secure multiple servers and protect against cyber attacks when compared to centralized systems. But the security of edge functions mainly relies on the cloud provider you select.

Wrapping up

In conclusion, edge computing and edge functions are rapidly becoming popular in the technology industry because of their ability to provide faster and more reliable processing by bringing computation power closer to the end user. Edge functions, when implemented correctly, can significantly decrease latency, provide a more efficient serverless backend, automate processes, and improve performance in a variety of industries. As technology continues to advance and demand for edge computing increases, edge functions will become even more essential for businesses and developers looking to stay competitive in the industry. With the advancements in technology and the increasing demand for edge computing, it’s the perfect time for developers and cloud providers to explore and take advantage of the benefits of edge functions.