By Jim White, EdgeX Foundry TSC Chair
Recently, the EdgeX Foundry project (a Linux Foundation project and part of the LF Edge umbrella of projects), released a dot release (v2.1) on top of our second major release which came out this summer. This release was codenamed Jakarta and it is the community’s 9th overall release. Jakarta was a stabilization release and is our first long-term support (LTS) release.
In reading my blog post title, you may be asking, what is this joker-of-a-technical-steering-committee-chairman talking about? The paint on EdgeX 2.0 and our first ever LTS isn’t even dry and he’s talking about the third major release?
To put everyone’s mind at ease, EdgeX 3.0 is a long way off. EdgeX 2.0 was a very big release. The LTS release was a big commitment of support on the part of our community (we will support Jakarta for 24 months as defined by our LTS policy). Furthermore, the community recently held its semi-annual planning meeting for the next release (codenamed Kamakura), and we know the spring 2022 release will be another dot release (EdgeX 2.2) with some additional new features but still backward compatible with all 2.x releases. So, there is nothing on the immediate horizon that says EdgeX 3.0 is eminent.
I am not going to put a timeline on EdgeX 3.0 availability. As a project, I am very proud of the fact that we have regularly released twice a year. In 4 years of existence, EdgeX has had just 2 major releases. EdgeX 3.0 would be the third, and given our current cadence. Do the math and you can see that we are looking at more than year before EdgeX 3.0 is even remotely possible. EdgeX 3.0 here serves as a metaphor of what big things are on the horizon for the project.
What I am going to pose in this post is a vision and a roadmap for the future of EdgeX Foundry. I have the privilege of owning a front row seat in the creation and use of EdgeX for more than 6 years now. I don’t suggest that I have all the answers or perfect vision with regard to the future, but I think my position grants me enough context and understanding to make some forecasts. History combined with current requirements sprinkled with a few strong technical indicators can present a pretty good directional.
To provide future me and my prognostications some escape, I include a couple of caveats with regard to my “vision”: major industry disruption and time. What I am presenting is a vision based on technology we know today or expect tomorrow. Significant disruption (i.e., Internet or smartphones size impacts) is not something I can predict and it would potentially make this roadmap useless. I am also not suggesting everything I am envisioning will be or even has to be in EdgeX 3.0. The vision is a guidepost, but the journey may take a bit longer and more than one major release to accomplish – so again EdgeX 3.0 is metaphorical.
OK – that said, allow the crazy TSC chairman to paint the picture of EdgeX 3.0.
Take the Bus but Allow Walking
When EdgeX was initially introduced, all service communications were via REST. Whether your application needed something from an EdgeX service or two EdgeX services needed to talk, we used REST over HTTP. This was a conscious decision. We felt that REST was clean, simple and well understood. If you are looking to get adopted and you have a complex tool to solve complex problems, you at least want to make it easy to communicate with. REST is pretty easy to work with.
Quality of service needs, throughput efficiency, pub/sub model vs point-to-point communications, and message size are reasons why architects choose a message bus approach over REST. These reasons are valid reasons to adopt messaging in edge/IoT computing too.
Over time, EdgeX has instituted more message bus communications for our services. As of EdgeX 2.0, All communications from sensor to enterprise/cloud (the northward travel of the sensor data), can be done via message bus to deliver edge data.
In EdgeX 3.0, adopters must have the opportunity to use a message bus for all communications. Most notably, an enterprise application or cloud system should be able to send a message on a message bus (MQTT, AMQP, Redis Streams, etc.) to request actuation on a device/sensor or to get details about what is happening at the edge. Today, communications from north to south are all via REST. Queries into EdgeX services or requests to change metadata, schedules or any type of configuration are also via REST. Going forward, EdgeX 3.0 needs to allow communications with all services to happen by message bus. That means all EdgeX services will need to be outfitted with topic endpoints and subscriptions to receive messages as well as the means to publish a message to a message bus.
This does not mean REST should be removed. EdgeX is also about flexibility and simplicity. REST interfaces suffice for some production use cases. Further, REST makes it easier for a student of EdgeX to get up to speed and explore the platform. REST also offers a great deal of assistance when debugging a broken system. Use of REST allows users to walk around the services with a simple browser (whether trying to learn it or fix it), and with no additional setup or tools.
Finally with regard to EdgeX 3.0 and messaging, the platform should also embrace AMQP as an alternative to MQTT and Redis Pub/Sub (and ZMQ in some limited cases). AMQP offers more features such as better support for cache and proxy. AMQP is popular among some industries (finance and business) and is used in some IoT circles (notably supported in Microsoft’s Azure IoT Hub). Because AMQP requires more resources (see issues with resource constraints below), it should not be the default message bus implementation. Providing an optional implementation of the EdgeX message bus via AMQP, however, allows EdgeX to compete with products at the edge using this protocol and give it one more tentacle of flexibility.
Size Matters and Time is Relative
Since the beginning of my journey in IoT/edge computing, we were always working in limited resource environments but with the hope and expectation that Moore’s law would eventually be applied at the edge just as it has on our desktops, phones, enterprises and clouds. This is a false assumption.
I do think that the availability of resources at the edge is trending upward – it just happens much more slowly than every two years (per the law). Why? Two reasons: scale and time.
If your company was to replace all of its employee laptops, how many laptops would they be replacing? Hundreds? Thousands? Sizeable yes. And not cheap, but IT organizations rotate our laptops about every 2-3 years as a matter of course. Agile development practices have our enterprise applications updated every few weeks.
Now imagine you are a city and you want to put an edge compute platform on every traffic signal. Back of the napkin math says there are about 200 to 6000 compute platforms you are going to need for a square mile of city (using 4-12 lights per intersection, and about 45-550 intersections per square mile in a city – thanks Google). How many square miles in a city? Given Philadelphia has around 130 mi2 and Seatle has around 80 mi2, let’s just say 100 mi2 as a good working number. That means we would need to field 20K to 600K platforms! The cost to stick a high-end server with lots of resources on each traffic light would break a city. The sheer scale of the deployment is too big to expect the use of something other than smaller/cheaper edge platforms. This is not an isolated case. IoT / edge deployments tend to get very big, very quickly.
Second reason – Moore’s law generally applies to information technology (IT) areas much better than it applies to operational technology (OT) areas. Einstein was right – time is relative. In OT realms, the rate of change is slower – much slower. So even if companies, governments and institutions had access to cheaper, faster and bigger, stronger technology, deploying it into the hot, smelly, dirty, wet, corrosive and generally hard to reach places that edge computing goes to doesn’t happen overnight. Getting to these systems can be a nightmare. Most systems in OT stay in place at least 7 years. It is not unusual to find edge technology that is in place for 15 years or more. This is a far cry from the 2-3 year (or less) upgrade cycles found in IT environments.
Consequently, the environments that a platform like EdgeX needs to run in are constrained and likely to remained constrained for some considerable time into the future.
EdgeX started life as a Java platform. It was too big to meet edge resource constraints. We’ve worked hard to get our micro services lean and to operate in limited resource environments. We also made an increasing number of services optional (use a minimal set of EdgeX services to support bare bones use cases).
As a project, we have to fight the urge to add to the platform such that it can only be used in expensive, non-resource constrained environments. From the project’s onset, we used a small Raspberry Pi as our guidepost. We were not endorsing Raspberry Pi. It was a measuring stick. If we could run EdgeX on that platform, we were within the realm of being able to run in a smaller, resource constrained, and yes cheaper, edge environment.
That measuring stick is still relevant to EdgeX 3.0 for reasons stated above.
- EdgeX needs to run in 1GB of RAM or less.
- EdgeX can run on a single core platform
- EdgeX needs to run within 32GB of storage space.
- EdgeX needs to be able to ingest sensor data, make a decision (from a rules engine or other analytics package), and actuate a device in less than one second (within a single instance of EdgeX).
- EdgeX needs to startup and be operational is 10 seconds or less.
There are some implications of this that are mentioned in other future platform decisions below (such as use of 3rd party components). But importantly, as we add to EdgeX, we must take care not to allow EdgeX to get so big as to grow beyond the constraints of its slow-changing OT environment.
Adopt Versus Build – Finding Edge Worthy Components
For expediency and because the areas were not our specialty, the EdgeX community choose to adopt some enterprise grade open-source products. We chose Drools initially to give us a rules engine to drive low latent decisions at the edge. We incorporated Kong and Vault to provide our security API gateway and secret store. We use Consul for our configuration/registry service by default. We initially chose MongoDB for persistence.
These were the right decision at the time. We took a path where we do the edge and we let others do the things that they are good at. “You do you” we said to 3rd party components and “we’ll do edge.” Security, in particular, is not something we felt we should be creating on our own.
Over time, we have chosen alternates to help lower the EdgeX resource footprint. We replaced MongoDB with Redis. We chose eKuiper to replace Drools. Still, it was a relatively hands off approach to incorporating best of breed 3rd party components. Again – “you do you” and “we’ll do edge.”
But many of these choices, due to their enterprise and cloud native nature, are big – too big. They are wonderful, but offer more capability than what will ever be used at the edge. They were not built for the edge. eKuiper being an exception, but even there we have seen a large expansion of their feature set to address more (and perhaps more than the edge needs?). The you-do-you, and we-do-edge approach is something we need to reconsider for EdgeX 3.0. As a customer said to me recently, “EdgeX needs a diet plan.”
Have a look at the EdgeX performance numbers in the table below. With regard to EdgeX services, most are under 25MB or less image footprint. Memory usage by any EdgeX service is around 11MB and CPU utilization is miniscule. Now note the size of the non-EdgeX services (those without the EdgeX prefix). The numbers are stark. Over the last few releases, EdgeX services are trending within a few megabytes of their original performance numbers (some even getting smaller). 3rd party services are getting bigger. Its not that EdgeX needs a diet plan so much as we need to put our 3rd party components on a diet plan.
It is the 3rd party components that are costing EdgeX most on its ability to fit on resource constrained platforms. There is a chance that there are still other, smaller options for some of these components. But are the options built for the edge and with an edge attitude toward resource constraints?
EdgeX has come to a point where it must consider one of a few options in adoption of 3rd party components:
- Locate 3rd party component providers that are thinking edge resource constraints and use their smaller components to replace the current enterprise sub-systems we use today.
- Partner with the current 3rd party component providers; give them our edge and resource requirements, and see if they are willing to create smaller, lighter versions of their products for the edge.
- Create our own smaller, lighter components to address edge needs. Perhaps start from trying to take an existing open-source product and cut it down; more limited in functionality but fine for the edge.
- Allow adopters to unplug the heavy bits or implement their own. Some use cases don’t require the 3rd party components. When they are required, and by providing abstractions for all 3rd party components, EdgeX can continue to use the same 3rd party components as implementations for those abstractions, but make it easier for adopters and commercial implementers to create or select alternate implementations as use case resource constraints dictate.
I prefer these in order. Finding other alternates has so far proven to be a challenge. I recognize that other projects have their own priorities and supporting edge computing may not rise to a level of their concern (although one would hope that the size of the IoT edge opportunity would attract some). Almost certainly, a project like eKuiper (now a sister project in LF Edge) would be open to finding ways to modularize or otherwise offer resource constrained functionality for resource constrained edge platforms.
Where we cannot find or convince a third party, open-source project to help meet our component need, EdgeX may have to look at implementing their own. A dubious sounding task, but in actuality may not be that daunting given that edge needs are a map-reduce function against the bigger enterprise versions. Depending on the architecture, we may find we can take a selective scalpel to the 3rd party component and create an edge worthy edition reasonably quickly.
There are some use cases where the security components are not needed (in physically restricted environments for example). Some adopters may just drop the weight of our enterprise level components if we make it easy for them. Forcing adopters to have to create their own components based on our abstractions should be used only as temporary fix or the answer when well-known, proprietary options exist for adopters to use in production deployments.
No longer can we just do “edge parts”. If a 3rd party component was built for the enterprise / cloud and is not meeting our edge needs, we must begin to explore alternatives – to include our own implementation – to satisfy edge resource constraints.
We are going to want to add additional capability to EdgeX (as discussed in various parts of this document). We are going to want to improve the platform. If we want to stay within the resource constraints of our target host platform, we are going to need to reduce resource consumption in 3rd party areas to allow EdgeX to grow in other areas.
Not Cloud Native – Aim for Edge Native
Cloud native is the current rage in software development. It is a term used to describe building and running applications that exploit cloud computing delivery models. That is, the ability for an application to access compute resources in more of an on-demand way with scale, resiliency and flexibility in mind. Specifically, cloud native applications take advantage of micro service architectures, containerized deployment and orchestration, agile development process, 12-factor app patterns, and good DevOps automation to usher work from code to deployable artifact.
There is a movement to drive cloud native principles in software engineering to the edge. While there are some good aspects of cloud native computing that can be applied directly, using a cloud native approach on edge applications forgets many of the constraints of the edge (see here for a good list of some of those differences). Others are calling for a modified approach that considers the unique requirements of the edge. That is, they are cherry-picking elements of cloud native but still considering the constraints of the edge. This approach is called edge native.
EdgeX has adopted some elements of the edge native approach (small micro services, service availability tolerance, good DevOps automation, etc.). In fact, EdgeX adopted some of these elements even before the term edge native existed. I believe that our EdgeX community would agree with the general philosophy in edge native computing. That is, we would agree that edge applications should be “built from the ground up with the Edge in mind – just like Cloud-Native applications are built for the Cloud.”
The definition of edge native is still somewhat nebulous and debated. Depending on the source, EdgeX adheres to some elements of edge native, but does not adhere to other characteristics. And there are some guidelines of developing edge native applications that I would not suggest EdgeX adhere to blindly.
As an example, use of containers is considered a staple (required?) in many edge native guidelines. EdgeX has always provided containers, but doesn’t require use of containers. In fact, the project supports alternate delivery technologies (like snap packages – developed by Canonical) and understands the reality of today’s edge infrastructure.
- Some OT groups have not embraced containerized workloads and have suggested it may be several years before they support containers in production.
- Some resource constrained platforms make use of containers impossible.
- Certain devices/sensors are going to make an all-container strategy a challenge.
While EdgeX supports container use, it does not dictate it. Flexibility is key so long as the edge is very heterogenous.
What principals of edge native computing should EdgeX look to embrace that it does not do today?
Edge native applications should be able to move as resources (compute, network, storage, etc.) dictate. Services should be able to scale out to the edge or scale back to the enterprise / cloud as resources warrant. For example, an application service could run at the far edge and provide for low-latency decisions when resources are available. But they may also run in the enterprise or in the cloud when resources aren’t available.
In theory, EdgeX services were designed to be distributed on different hosts (on physical systems or virtual machines with a different IP address). However, in reality, there are a number of issues with the current architecture that might make distributing services across hosts difficult. Chief among them is that when the services are distributed, there isn’t an easy way to secure the communications between services – a necessity for edge native applications. Providing central configuration and secrets across the distributed services is not fully addressed in EdgeX. EdgeX 3.0 needs to allow any EdgeX micro service to live anywhere, anytime and still operate securely.
Resiliency and Rapid Recovery
Enterprise and cloud platforms and associated resources (compute, network, storage, etc.) are relatively stable. Edge platforms are notoriously unstable. EdgeX 3.0 needs services to be more resilient to edge failures and outages. When service failures do occur, the services need to be brought back up quickly.
This does not mean EdgeX services need to be “highly available.” High availability (HA) is the ability of a system or service to operate continuously without failing for long, agreed upon lengths of time. It often requires some orchestration capability to monitor the services and offer “backup” or redundant services in the face of failure. The resource constrained nature of edge platforms makes offering HA at the edge a particular challenge.
Dependent services will go down. Resources like the network will become unavailable. The EdgeX 3.0 services must be built to be withstand these issues. When a service does go down, it must be able to be restarted quickly and not require a lot of new configuration or setup on the part of the user (such as new security keys that cannot automatically be provisioned).
I submit that in EdgeX 3.0, a service remains up and continues to try to acquire any dependent services or resources indefinitely unless trying to do so creates other issues. It should also be able to use the alert/notifications service (if it is up) to alert on the situation to a default HTTP REST endpoint, send an email, SMS message or otherwise alert the systems overseer. When the dependency is available, the service should come back on line and continue normal functions without the need for other intervention on the part of the user.
When a service fails, it should be able to restart within the one-minute system startup time and without other intervention on the part of the user that had to issue the start (or restart) command.
The community should also offer example scripts or services that would check that all services are functioning and when a service (or dependent facility such as the database) are down, it attempts to restart them. The example “restart” service or script does not have to be part of a default EdgeX 3.0 deployment, but should serve to help adopters think about how to keep an edge system alive even during partial failures.
Indeed, when something like Kubernetes is used to deploy and orchestrate EdgeX services, resiliency and rapid recovery may be offered taken care of by that environment. But EdgeX must always be able to handle itself when platform constraints don’t allow for CNCF types of deployment management.
The Other Data – EdgeX Control Plane Telemetry and Health / Monitoring
Today, EdgeX does not report on its own health and operations. Therefore, there is no way to automate any type of higher order management of the platform. For example, there would be no way to know if a device service is reporting sensor data as expected – at least not without manual intervention and exploration of log files (provided the right log levels are set).
Starting with the Delhi release, EdgeX offers a system management service. This service was created to be able to perform a limited set of monitoring and control plane functions. This includes:
- Starting, stopping, restarting the EdgeX services
- Providing memory and CPU usage of the service
- Provide a service’s configuration
- Provide an indication of whether the service is operational based on its response to ping requests
Because some of these functions (start, stop, restart and metrics collection) are dependent on how the services are deployed and running (via container or on a native Linux OS), the architecture of the service requires an “agent” request information from a specific platform-dependent “executor” to carry out much of the system management service functionality. The system management service, therefore, suffers from several issues:
- It doesn’t work for all environments (Windows)
- It has to be informed of all new or removed EdgeX services (not easy to do in dynamic situations)
- The architecture (two components versus a single service) makes it more difficult to setup and run
Perhaps, most importantly, the service isn’t providing any capability that couldn’t be obtained from use of other tools depending on how EdgeX is deployed and where it is running. For example, if EdgeX is deployed via Docker containers, Portainer or Linux tools could be used to do most of the system management functions except for providing configuration which is always available via Consul.
The intention was that the system management service would eventually be extended to get more information from each service (telemetry and event information that was specific to EdgeX) and make that available to monitoring services and/or other applications. The telemetry and event information is not something an outside tool could provide since it would require knowledge and access to EdgeX service internals.
Where that leaves the project is with a service that is redundant to better tools and technology and unable to provide much needed (and otherwise unobtainable) telemetry data that it should be providing. For this reason, the community has decided to mark the service deprecated with the Jakarta release. It may not be removed from the platform until something else provides for its replacement, but at least the community is signaling that the system management service in its current form is nearing end of life.
By the way, as reported earlier in this post, the system management agent (SMA) is the most expensive service in the EdgeX inventory by a factor of 10. So, removing this service as it exists today in EdgeX paves the way for additional features going forward.
EdgeX 3.0 needs to offer much more data to adopters about its health and operations. Telemetry or metrics from each service can be used to understand whether a sensor is reporting correctly, if the system has the proper resources to support adding additional sensors, or even if sensors are being used to flood the system with information (denial of service through sensors).
Rather than collecting telemetry by having an outside service request (pull) it, each service needs to be able to publish (push) telemetry out. The telemetry can be pushed anywhere. In early implementations, EdgeX services may just be configured to send telemetry to a designated message topic where it is up to the adopter to figure out how to collect, use or respond to any telemetry. Later, the telemetry data can be treated as alternate edge data (control plane data vs sensor data) that is consumed by EdgeX application services, rules engines or other analytics services. Telemetry data does not originate from a “thing”, but its data can help drive operations and actuation at the edge as necessary.
For example, imagine a device service reported telemetry about the number events it produced over a given period of time. If the telemetry – in the form of control plane Events/Readings – were picked up by application services and routed to the rules engine, the rules engine could be configured to look out for sensors reporting more events than expected. This could trigger the shutdown of that rogue sensor until a user explores the reason for the extra reporting.
Application services could also subscribe to service telemetry messages in order to filter, aggregate and otherwise prepare and ship telemetry data out of EdgeX – just as they are used to export sensor data today.
Each service is responsible for certain functions and responsibilities within an EdgeX instance. Each service knows (or should know) what is critical to its operations and functions. Therefore, each service should have the means to report telemetry specific and important to that service, and make this EdgeX specific information available to EdgeX as well as external systems.
The Event/Reading structure and services that handle Event/Readings may need to be modified slightly in recognition that the Event/Reading may contain sensor data or service telemetry data. Hopefully, Telemetry data and sensor data Event/Readings will differ only slightly in EdgeX 3.0 thereby requiring only minimal change.
EdgeX 3.0 services will need additional configuration so as to control how much and what telemetry gets reported. The user should be able to increase or decrease the telemetry reporting based on operational circumstances and use case needs (not unlike how logging output is adjusted today). Telemetry or metrics collection can impact the performance of EdgeX services. There may be a need, based on resource constraints in some deployments, to complete turn off telemetry collection and publication for the entire instance.
The basic premise of initial EdgeX telemetry collection is already specified in a proposed EdgeX ADR.
More EdgeX 3.0 Features
In addition to the vision provided above, EdgeX 3.0 will need to add some additional capability that it does not have today.
Alternate Language App Functions SDK
EdgeX has two device service (DS) software development kits (SDKs); one in Go lang and the other in C. Since most of the platform is created in Go lang, it seems fitting and natural to have a DS SDK in Go. We also have a DS SDK in C because it is the most natural fit for most low-level protocols and “thing” communications.
On the north side, we have just a single App Functions SDK to create new/custom application services (AS) in Go Lang. Again, given EdgeX’s foundation in Go, a Go lang SDK here also makes sense. Going forward, I anticipate more interfaces with artificial intelligence (AI) / machine learning (ML) and other analytics packages. One of the more popular languages for the AI/ML communities is Python. It would seem appropriate that EdgeX 3.0 provide a north side SDK that is more familiar to those more likely to need and build AS. Other organizations are using EdgeX to translate from one OT protocol (like Modbus) to another OT protocol (like BACnet or OPC UA). OT people tend to use C and C++ and it stands to reason that an App Functions SDK in one of these languages may better support their needs. In general, the SDKs at either north or south end of EdgeX need to tend toward the language tendencies of the user groups most likely to use them.
Distributed Ledger Support
IoT platforms are anticipated to generate 80 zettabytes of data by 2025 by one recent report. As that data begins to be shared – potentially even bought and sold on the open market – the origination, legitimacy, and ownership of that data is going to need to be monitored and managed. This screams for distributed ledger technology (DLT). The closer that the data can be tracked and attributed, the better. This means that IoT/edge platforms like EgdeX will need to integrate with DLT platforms in order to put its sensor data into a digital ledger.
EdgeX 3.0 will need to offer some initial integration to popular, open source DLT. DLT can be resource intensive. So DLT at the edge may be an option to be used only when the use case dictates it and the edge platform can support it.
K8s Is Coming
I said earlier that EdgeX 3.0 will move closer to edge native, but that doesn’t mean it has to offer high availability. However, without a doubt, Kubernetes (K8s) is moving to support the edge. K3s, MicroK8s, KubeEdge and other efforts stemming from the Kubernetes are just the forerunners to what will be some type of K8s support at the edge.
Not every organization will support its use at the edge – it can be complex. Not all edge environments will have the resources to run some form of K8s at the edge. And using K8s in whatever form it takes to deploy and orchestrate edge native applications will have to make some allowances for edge constraints and challenges. But make no mistake, like winter, K8s is coming. EdgeX 3.0 will need to do more for those looking to use K8s. Providing deployment / orchestration assistance equal to that which we do for Docker Compose and Snaps will be imperative.
We have always claimed to be deployment/orchestration technology agnostic. We will remain so. But at some point, we should expect some form of K8s technology (probably a far cry from what we see today which is largely inadequate to edge native) to be the predominant means of deploying edge applications. We will also have to educate those coming from a cloud native world why K8s is not always a fit for edge native.
We have already begun a conversation in the community about how to support unit of measure standards with regard to our sensor data collection. That is, how to attribute sensor data to a well-defined unit of measure.
IoT / edge platforms have been be specific about the sensor data collected. For that matter, devices are pretty lack with regard to how they send data. I own two IoT temperature probes that send an integer of “793” when trying to tell me the temperature reading is 79.3 Fahrenheit.
In order for the sensor data to be more trusted and offer better value (see DLT comments above), the data will need to be tied to an appropriate unit of measure and that unit of measure should be well defined by some body.
EdgeX 3.0 will not create or dictate the unit of measure standard, but it will allow those that need more specificity to label sensor data with a unit of measure and the standard it comes from.
This discussion and the premise for a unit of measure solution are already specified in a proposed EdgeX ADR.
Automate Thing Provisioning
The “last mile” is a term that originated in supply chain management and then adopted by telecommunications. It was used to describe the most difficult part of a journey or furthest part in a network – which usually was found at the end or literally the last mile.
In edge computing, the last mile is that between our platform and the actual device or sensor. Connecting the sensors or devices with all the protocols, data formats, complex hardware, etc. is a real challenge and is why EdgeX is so important. EdgeX, as we know, helps to simplify and standardize how “things” of the OT world get connected to the IT world.
While EdgeX makes the last mile shorter, so to speak, there is still a fair amount of ceremony and work required to provision a new sensor. As an EdgeX user, you still have to provide a device profile, issue the correct Metadata calls or providing the right device configuration in order to onboard a new “thing”. We provide some amount of device discovery and automated provisioning, but it is limited to a few protocols and doesn’t go far enough.
Many sensors/devices today can provide more information about the resources they have to offer or the actuation commands they support. Many sensors/devices advertise their presence and offer platforms like EdgeX the ability to discover and onboard them automatically.
EdgeX 3.0 needs to complete the journey and make the last mile of connectivity easier for adopters. Where possible, and with appropriate safeguards, EdgeX 3.0 should be able to onboard a new senor/device as soon as it is powered up and in communication range of EdgeX and the host it runs on.
There will be challenges, especially with more legacy protocols. However, an edge platform that enables “thing” connectivity simply by powering the sensor on will help to make IoT / edge computing truly more ubiquitous.
The opinions and vision expressed in this post are my own. While I am currently the EdgeX Foundry TSC chairman, the vision depicted here is not yet the opinion adopted by the EdgeX community. It is not the codified roadmap for EdgeX. I hope it will be – or that the community will take this vision and improve upon it, which they usually do. “A goal is not always meant to be reached; it often serves simply as something to aim at.”
We’ve spent the last two years working on EdgeX 2.0 and our first LTS release. I am so proud of the work that was accomplished and where EdgeX is at, but I don’t want adopters or the community to think we have reached the end. We are not at the end. We are at the beginning of creating the best open source IoT / edge platform on the planet.