From 86435f53ab3d0aa064093cace0fa42e010eb857c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E5=9B=BD=E5=AE=9D?= Date: Sun, 4 Feb 2024 12:56:48 +0800 Subject: [PATCH] Update and rename README-EN.md to README.EN.md --- README-EN.md | 46 ---------------------------------------------- README.EN.md | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 46 deletions(-) delete mode 100644 README-EN.md create mode 100644 README.EN.md diff --git a/README-EN.md b/README-EN.md deleted file mode 100644 index 9710bf1..0000000 --- a/README-EN.md +++ /dev/null @@ -1,46 +0,0 @@ -# Sekiro -SEKIRO is a multi-language, distributed, network-topology-agnostic service publishing platform. - -It publishes functions to a central API marketplace by writing handlers in different languages, - -and business systems can use the capabilities of remote nodes via RPC. - -For more information, please refer to the detailed documentation: https://iinti.cn/sekiro/ - - -## Sekiro is an RPC framework - -that mainly supports multi-node program calls, so it belongs to the RPC (Remote Procedure Call) framework: - -API management, authentication, distribution, load balancing, and cross-language support. - -## However, Sekiro is not a conventional RPC framework. - -In general, RPC frameworks are used in backend microservices to split complex business modules and to enhance the performance bottleneck of a single machine in a multi-node cluster. - -They are usually a group of business machines in a single data center that call other business machines. Dubbo, springCloud, and gRPC are representative RPC solutions on the market, and they are all world-class projects. - -However, Sekiro is not a solution for this typical RPC capability scenario. - -Sekiro mainly provides the function of exposing restricted context environments. - -Providers run in a restricted environment, which means that the service cannot be easily transferred as a normal algorithm to an internal service. However, businesses want to use this restricted environment's function. - -- For example, if an encryption algorithm runs in a client program and the service needs to use it but has not cracked the algorithm, Sekiro can inject code into the client and then publish the algorithm's API. -- Similarly, if a piece of data is restricted for internal network use only, but the business wants to use it for external services, a Sekiro client can be written within the internal network to implement API publishing. -- If an app or terminal program has the ability to be used by C-end customers, but the business wants to use this ability for B-end, it can be connected through Sekiro, with B-end parameters forwarded to the app for proxy calling capability. -- Service providers may have a capability that needs to be used by others, but they do not want to deliver the code or leak the machine (IP address, etc.) that corresponds to the service. In this case, they can use Sekiro to publish the service. Others can only use the capability through Sekiro without knowing any details of it. - -## The core process involves a central server: - -1. the Sekiro central service, which needs a server-side connection that can be connected by consumers and providers. -2. Clients are available in multiple languages, such as Java, JS, and Python, and these languages are used to communicate with the Sekiro central server and package the API. -3. Users can write handlers using the Sekiro client API in their respective languages to accept parameters and complete the forwarding call to the real capability, connecting the Sekiro service and the local environment service. -4. External users call the Sekiro central service API, which is then forwarded to the corresponding client handler by the Sekiro service. After obtaining the call result, the original link is returned to the user. - -# To build Sekiro, -- Java and Maven need to be installed. - -- After executing the script build_demo_server.sh on Linux/mac, the target/sekiro-open-demo.zip file is produced. -- Then, execute the script bin/sekiro.sh or bin/sekiro.bat to run the service. -- The documentation is available at http://127.0.0.1:5612/sekiro-doc if the service is deployed on your local machine at 127.0.0.1. \ No newline at end of file diff --git a/README.EN.md b/README.EN.md new file mode 100644 index 0000000..a2b155d --- /dev/null +++ b/README.EN.md @@ -0,0 +1,40 @@ +# Sekiro [中文](./README.md) +SEKIRO is a multi-language, distributed, network topology-independent service publishing platform. It enables the publishing of functionalities to the central API marketplace by writing handlers in various languages. Business systems use the abilities of remote nodes via RPC (Remote Procedure Call). + +For more information, please refer to the detailed documentation: [http://sekiro.iinti.cn/sekiro-doc/](http://sekiro.iinti.cn/sekiro-doc/) + +Sample code for various languages: [https://github.com/yint-tech/sekiro-samples](https://github.com/yint-tech/sekiro-samples) + +Download the installation package: [iinti sekiro-demo https://oss.iinti.cn/sekiro/sekiro-demo](https://oss.iinti.cn/sekiro/sekiro-demo) + +## Sekiro is an RPC Framework +Sekiro primarily supports multi-node program invocation, thus it belongs to the RPC (Remote Procedure Call) framework category: API management, authentication, distribution, load balancing, and cross-language. + +## Sekiro is Not a Conventional RPC Framework +Usually, in backend microservices, RPC frameworks are mainly used to decompose complex business modules and enhance single-machine performance bottleneck capabilities through multi-node clusters. They are typically business machine groups within a single machine room, calling other business machine groups. Dubbo, SpringCloud, and gRPC are representative RPC solutions on the market, and they are all world-leading projects. However, Sekiro is not a solution for such conventional RPC capability scenarios. + +Sekiro's main function is to provide external functionality in a restricted context. The service provider (provider) operates in a restricted environment, making this service inconvenient to be transferred to internal services as a conventional algorithm. At this point, our business hopes to use this functionality in a restricted environment. + +* An encryption algorithm runs in a client program. The service needs to use it but has not completed the decryption of this algorithm. You can use Sekiro to inject code into this client and then publish the algorithm's API. +* A piece of data, due to permission restrictions, is only allowed to be used within the organization's intranet (checked by the organization's source IP), but we hope to call it in external services. You can write a Sekiro client in the organization's intranet to implement API publishing. +* An app (or terminal) program has capabilities for C-end customers, but we hope that B-end business can use this capability. Then connect it through Sekiro, and forward B-end parameters to the app, using the app to proxy call capabilities: (This is what the crawler industry calls an RPC crawler). +* The service provider has a capability that needs to be used by others, but does not want to deliver the code, and does not want to leak this service's corresponding machine (IP address, etc.). Then you can publish the service through Sekiro. Others can only use the capability through Sekiro and cannot understand any details of this capability. +* An algorithm that requires a complex computing environment and cannot be easily deployed in external services can use Sekiro to host the API in an available environment, and then export it to the outside. + +## Core Process +1. There is a central server: the Sekiro central service. It needs to be server-side and can be connected by consumers and providers. +2. There are clients in multiple languages, such as Java, JS, Python, etc., and these languages have implemented communication with the Sekiro central server and API wrapping. +3. Users write handlers in their respective languages using the Sekiro client API to accept parameters and complete the forwarding call to the real capability, connecting the Sekiro service and local environment services. +4. External users call the Sekiro central service API, which is forwarded by the Sekiro service to the corresponding client handler. After obtaining the call result, it returns to the user via the original link. + +## Build Tutorial + +- Install Java +- Install Maven +- On Linux/mac, execute the script: ``build_demo_server.sh``, and the output file is ``target/sekiro-open-demo.zip``. +- Run the script: ``bin/sekiro.sh`` or ``bin/sekiro.bat`` +- Documentation: [http://127.0.0.1:5612/sekiro-doc](http://127.0.0.1:5612/sekiro-doc) Assuming your service is deployed on localhost: ``127.0.0.1`` + +## Installation Package + +- [iinti sekiro-demo download](https://oss.iinti.cn/sekiro/sekiro-demo)