MEF

What's New

[2025.12.30]: 🚀 MEF Open-Source Release

Introduction

MEF is a lightweight edge-cloud collaboration enablement framework designed for integration. It is used to enable intelligent edge devices, providing edge-cloud collaboration capabilities such as edge node management and lifecycle management of edge inference applications. Edge-cloud collaboration management can be performed through MEF Edge and MEF Center. Users can integrate required features by connecting to Independent Software Vendor (ISV) service platforms through secondary development.

MEF Edge is deployed on intelligent edge devices, responsible for connecting to the central network manager, deploying and managing intelligent inference services (container applications), and providing services for algorithm applications.
MEF Center is deployed on general-purpose servers, responsible for batch management, service deployment, and system monitoring of edge nodes.

Directory Structure

Key directories are as follows. For a detailed directory introduction, see Project Directory.

MEF                             # Project root directory
├── build                       # Build-related directory
├── docs                        # Documentation directory
│   └── en                      # English documentation directory
└── src                         # Source code directory
    ├── common-utils            # Common utility library
    ├── device-plugin           # Device plugin component
    ├── mef-center              # MEFCenter central component code
    └── mef-edge                # MEFEdge edge component code

Version Description

For MEF version mapping details, see Version Mapping Description.

Compatibility Information

Table 1 MEF supported product forms and OSs

Installation Node	Software	Product Form	Software Architecture	OS
Management node	MEF Center	General server	AArch64 x86_64	Ubuntu 20.04 openEuler 22.03
Compute node	MEF Edge	Atlas 200I A2 accelerator module Atlas 200I DK A2	AArch64	openEuler 22.03 Ubuntu 22.04
Compute node	MEF Edge	Atlas 500 Pro AI edge server (model: 3000) (supporting the Atlas 300I Pro inference card)	AArch64	openEuler 22.03

Environment Deployment

Obtaining Software Packages

You can obtain the official version of the software package through this project, or build it yourself from source.

Official version software package
To compile and build the software package yourself, see Build Process.

Installation

Before installation and use, users need to understand the installation notes and prepare the installation environment. For details, see Installing MEF.

MEF Installation Flowchart

Build Process

This section uses Ubuntu 20.04 as an example to describe how to generate the MEF software package through source code compilation.

Dependency Preparation

Before compiling MEF, ensure that the necessary build tools and dependencies are installed on the system. The reference installation commands are as follows:

apt-get update
apt-get -y install texinfo gawk libffi-dev zlib1g-dev libssl-dev openssl sqlite3 libsqlite3-dev libnuma-dev numactl libpcre2-dev bison flex build-essential automake autoconf libtool rpm dos2unix libc-dev lcov pkg-config sudo tar git wget unzip zip docker.io python-is-python3 iputils-ping

In addition to the above tools and dependencies, you also need to install Golang and Cmake. The version requirements are as follows. Installation from source code is recommended.

Table 2 Dependency version requirements

Dependency Name	Recommended Version	How to Obtain
Golang	1.24.0	Obtain the source package for compilation and installation.
CMake	3.16.5 and later	Obtain the source package for compilation and installation.

Build MEF

Pull the complete MEF source code, and place it in the /home directory.
Go to the /home/MEF/build directory
```
cd /home/MEF/build
```
Modify the mef-version field value in the component version configuration file service_config.ini to the desired build version. The default value is as follows:
```
mef-version=7.3.0
```
Run the following command to execute the build script:
```
dos2unix *.sh && chmod +x *.sh
./build_all.sh
```
After execution is complete, obtain the compiled software package in the /home/MEF/output directory. Note that both MEF Center and MEF Edge software packages will be compiled under the AArch64 architecture, while only the MEF Center software package will be compiled under the x86_64 architecture.

Notes

The software supports Ubuntu 20.04 as the OS, but its build process uses glibc 2.34 (compiled from source). To avoid incompatibility issues caused by a higher glibc version, it is recommended to perform the build on Ubuntu 20.04.
If you encounter issues during the build process, check the error logs and ensure all dependencies and tools are correctly installed.

Test Case

The method for executing test cases is as follows. Note that test cases must be executed in an x86_64 architecture environment. Since some test cases use gomonkey for runtime function stubbing, which relies on architecture-specific assembly instructions and Go compiler behavior, they need to run on the x86_64 architecture.

Before test case execution, prepare the test environment by following the instructions in Dependency Preparation.
Install dependencies for measuring the test coverage and generating visualization reports. If a latest dependency version is incompatible with the Golang version, install a compatible version.
```
go install github.com/axw/gocov/gocov@latest
go install github.com/matm/gocov-html/cmd/gocov-html@latest
go install gotest.tools/gotestsum@latest
export PATH=$PATH:$(go env GOPATH)/bin
```
Execute test cases for each module separately (this project contains multiple modules). For details, see the following:

Execute the test case under the common-utils module

cd /home/MEF/src/common-utils/build
dos2unix *.sh && chmod +x *.sh
bash test.sh

Execute the test case under the device-plugin module

cd /home/MEF/src/device-plugin/build
dos2unix *.sh && chmod +x *.sh
bash test.sh

Execute the test case under the mef-center module

cd /home/MEF/src/mef-center/build
dos2unix *.sh && chmod +x *.sh
bash test.sh

Execute the test case under the mef-edge module

cd /home/MEF/src/mef-edge/build
dos2unix *.sh && chmod +x *.sh
bash prepare_dependency.sh
bash test.sh MEF_Edge_SDK

Quick Start

The application process of cloud-edge collaboration mainly includes installing MEF, secondary development and integration, and managing edge nodes and container applications. For details, see Usage Guide.

MEF Application Flowchart

Feature Description

Edge-cloud collaboration management can be achieved through MEF Edge and MEF Center. Users can integrate required functions by connecting to ISV service platforms through secondary development.

MEF Edge is deployed on intelligent edge devices, responsible for connecting to the central network manager, deploying and managing intelligent inference services (container applications), and providing services for algorithm applications.
MEF Center is deployed on general-purpose servers, responsible for batch management, service deployment, and system monitoring of edge nodes.

Table 3 MEF features

Function Type	Detailed Description
Node Management	Supports creating, querying, modifying, and deleting node groups. Supports node management, addition, modification, deletion, and query operations.
Container Application Management	Supports creating, querying, updating, and deleting container applications. Supports deploying container applications to node groups, uninstalling from node groups, and uninstalling from individual nodes.
Log Collection	Supports collecting and exporting MEF Edge logs for troubleshooting and device status monitoring.
Configuration Management	Supports importing, querying, and deleting root certificates. Supports importing certificate revocation lists. Supports configuring image download information, etc.
Alarm Management	Supports querying alarm or event information.
Software Upgrade	Supports online upgrade, same-version upgrade, and version rollback of MEF Edge through the MEF Center software upgrade API.
Northbound API	Provides APIG services for accepting external access, rate-limiting northbound APIs, and forwarding functions.

API Reference

For API reference details, see API Reference.

FAQ

For related FAQs, see FAQ.

Security Statement

Harden the system by following the instructions in Security Hardening Suggestions.
The security hardening measures in the Security Hardening Suggestions are basic hardening recommendations. You should re-evaluate the network security posture of the entire system based on specific service requirements. Users should perform relevant configurations according to the security policies of their organization, including but not limited to software versions, password complexity requirements, security configurations (protocols, cipher suites, key lengths, etc.), permission configurations, firewall settings, etc. When necessary, consult industry best practices and security experts.
Security hardening involves host hardening and container application hardening to prevent potential security risks and ensure the security of devices and container applications. Users should perform security hardening operations based on actual needs.
Software code or programs downloaded from external sources may pose risks. You must guarantee the security of their functions.
For details on the communication matrix, see Communication Matrix
For details about public network addresses, see Public Network Addresses
For details about environment variable descriptions, see Environment Variable Description
For details about the user information list, see User Information List

Branch Maintenance Policy

The maintenance phases for version branches are as follows:

Status	Duration	Description
Planned	1-3 months	Planned features.
Development	3 months	New feature development and issue fixes, released regularly.
Maintenance	3-12 months	Regular branches receive 3 months of maintenance. Long-term support branches receive 12 months of maintenance. Critical bugs are fixed, no new features are merged, and patch versions are released based on the impact of bugs.
End of Life (EOL)	N/A	The branch no longer accepts any modifications

Version Maintenance Policy

Version	Maintenance Policy	Current Status	Release Date	Subsequent Status	EOL Date
master	Long-term support	Development	Under active development and not yet released	-	-

Disclaimer

This repository contains multiple development branches, which may include unfinished, experimental, or untested features. These branches should not be used in any production environment or service-critical projects before an official release. Ensure you use our official release versions to guarantee stability and security. This project and its contributors are not responsible for any issues, losses, or data corruption resulting from the use of development branches.
For official versions, please refer to the official release version.

License

MEF is licensed under the Mulan PSL v2 License. The corresponding license text can be found in LICENSE.
Documents under the MEF docs directory are licensed under CC-BY 4.0. For details, see LICENSE.

Contribution Statement

Submit an error report: If you find a non-security-related bug in MEF, first search the Issues in the MEF repository to avoid duplicate submissions. If the vulnerability is not yet reported, create a new issue. If a security issue is discovered, do not disclose it publicly; please follow the security issue handling process. Always include complete information when submitting a bug report.
Handle security issues: Please notify the project maintainers via email for confirmation and further modification.
Resolve existing issues: Check the repository's issue list to find open issues that need attention. Feel free to try resolving one of them.
Propose a new feature: Please mark the issue with the feature label. We will periodically process and confirm development.
Start contributing:
- Fork the repository of this project.
- Clone it locally.
- Create a development branch.
- Run local self-testing. Ensure all unit tests pass before committing, including new unit tests for the issue you are addressing.
- Commit your code.
- Create a Pull Request (PR).
- Review code: Address review comments and update your PR accordingly. This may involve multiple iterations.
- Once your PR has received the required number of approvals, the committer will perform the final review.
- After the review and tests pass, CI will merge your PR into the project's main branch.

Suggestions and Communication

We welcome your contributions to the community. If you have any questions or suggestions, submit issues. We will reply as soon as possible. Thank you for your support.