This is an automated email from the ASF dual-hosted git repository.
albumenj pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/dubbo-website.git
The following commit(s) were added to refs/heads/master by this push:
new c3822a9e2ef Translate part features overview docs (#2836)
c3822a9e2ef is described below
commit c3822a9e2efd08f51bb9c904e44b954fa6a8944d
Author: namelessssssssssss
<[email protected]>
AuthorDate: Wed Oct 18 10:05:04 2023 +0800
Translate part features overview docs (#2836)
* Fix title issue
* Translate core-features/ecosystem
* Translate core-features/extensibility & core-features/load-balance
* Fix style
* Fix wrong aliases
* Fix wrong path
* Fix style
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Fix path
* Translate service-definition.md
* Translate service-discovery.md
* Translate service-discovery.md
* Fix path
* Fix path
* Fix path
---
content/en/blog/proposals/_index.md | 5 +
content/en/blog/proposals/service-discovery.md | 5 +
.../overview/core-features/service-definition.md | 149 ++++++++++++++++++++-
.../en/overview/core-features/service-discovery.md | 57 ++++++++
content/en/overview/quickstart/go.md | 6 +
content/en/overview/quickstart/rust.md | 6 +
6 files changed, 226 insertions(+), 2 deletions(-)
diff --git a/content/en/blog/proposals/_index.md
b/content/en/blog/proposals/_index.md
new file mode 100644
index 00000000000..343d1fd08c9
--- /dev/null
+++ b/content/en/blog/proposals/_index.md
@@ -0,0 +1,5 @@
+---
+title: "Proposals About Apache Dubbo"
+linkTitle: "Proposals"
+weight: 20
+---
\ No newline at end of file
diff --git a/content/en/blog/proposals/service-discovery.md
b/content/en/blog/proposals/service-discovery.md
new file mode 100644
index 00000000000..05cb1a4851a
--- /dev/null
+++ b/content/en/blog/proposals/service-discovery.md
@@ -0,0 +1,5 @@
+---
+title: "Application-Level Service Discovery"
+description: >
+ The Application-Level Service Discovery
+---
\ No newline at end of file
diff --git a/content/en/overview/core-features/service-definition.md
b/content/en/overview/core-features/service-definition.md
index 16885279eb3..18bacab96eb 100644
--- a/content/en/overview/core-features/service-definition.md
+++ b/content/en/overview/core-features/service-definition.md
@@ -1,6 +1,151 @@
---
type: docs
-title: "Dubbo 微服务开发"
-linkTitle: "微服务开发"
+title: "Develop microservice with Dubbo"
+linkTitle: "Microservice develop"
weight: 1
---
+Dubbo addresses a series of challenges from development and deployment to
governance and operations in enterprise microservices. Dubbo provides a full
suite of services for developers, from project creation, development testing,
to deployment, visual monitoring, traffic governance, and ecosystem integration.
+
+### Development
+
+* **Language Support**: Dubbo supports various programming languages including
Java, Go, Rust, Node.js, and defines a set of paradigms for microservice
development. A corresponding scaffold is available for quickly creating a
microservice project skeleton.
+* **Deployment**: Dubbo applications can be deployed in different environments
including virtual machines, Docker containers, Kubernetes, and service mesh
architectures.
+* **Service Governance**: Dubbo provides capabilities like address discovery,
load balancing, and traffic control. It also offers an Admin dashboard for
visual control and a rich microservice ecosystem.
+
+#### Creating a Project
+The [Dubbo Microservices Project
Scaffold](https://start.dubbo.apache.org/bootstrap.html) can be used to quickly
create a microservices project. The scaffold can generate a microservice
project with necessary dependencies based on the features or components you
want.
+
+#### Developing Services
+**1. Define the Service**
+
+```java
+public interface DemoService {
+ String hello(String arg);
+}
+```
+
+**2. Implement Business Logic**
+
+```java
+@DubboService
+public class DemoServiceImpl implements DemoService {
+ public String hello(String arg) {
+ // your microservice logic here
+ }
+}
+```
+
+#### Publishing Services
+**1. Publish the Service Definition**
+
+The service provider needs to publish the service definition as a Jar package
to the Maven central repository.
+
+**2. Expose the Service**
+
+Add Dubbo configuration and start the Dubbo server.
+
+```yaml
+dubbo:
+ application:
+ name: dubbo-demo
+ protocol:
+ name: dubbo
+ port: -1
+ registry:
+ address: zookeeper://127.0.0.1:2181
+```
+
+#### Consuming Services
+
+First, consumers include the `DemoService` service definition dependency via
Maven/Gradle.
+
+```xml
+<dependency>
+ <groupId>org.apache.dubbo</groupId>
+ <artifactId>dubbo-demo-interface</artifactId>
+ <version>3.2.0</version>
+</dependency>
+```
+
+Then, programmatically inject the remote Dubbo service instance.
+
+```java
+@Bean
+public class Consumer {
+ @DubboReference
+ private DemoService demoService;
+}
+```
+
+### Deployment
+Dubbo native services can be packaged and deployed to cloud-native
infrastructures like Docker containers, Kubernetes, and service meshes.
+
+### Governance
+For service governance, most applications just need to add the following
configuration. Dubbo will then have address discovery and load balancing
capabilities.
+
+```yaml
+dubbo:
+ registry:
+ address: zookeeper://127.0.0.1:2181
+```
+
+Deploy and open the [Dubbo Admin Dashboard](/zh-cn/overview/tasks/deploy/),
and you will see the service deployment and invocation data.
+
+Dubbo Admin can also improve development and testing efficiency through
additional capabilities like:
+* Document management for regular services and IDL documents
+* Service testing & service Mock
+* Service status inquiry
+
+For more complex microservices scenarios, Dubbo also provides more advanced
governance features, including:
+* Traffic governance
+* Dynamic configuration
+* Rate limiting and degradation
+* Data consistency
+* Observability
+* Multi-protocol
+* Multiple registries
+* Service mesh
+
+This guide provides an overview of the workflow for developing microservices
with Dubbo. For detailed step-by-step instructions, please refer to:
+* [Getting Started with Java Microservices](/en/overview/quickstart/)
+* [Getting Started with Go Microservices](/en/overview/quickstart/go/)
+* [Getting Started with Rust Microservices](/en/overview/quickstart/rust/)
+* [Getting Started with Node.js
Microservices](https://github.com/apache/dubbo-js)
+
+
+### Deployment
+
+Dubbo's native services can be packaged and deployed in various cloud-native
infrastructures and microservices architectures, including Docker containers,
Kubernetes, and Service Mesh.
+
+For examples of deployment in different environments, refer to:
+* [Deploying Dubbo services to Docker
containers](/zh-cn/overview/tasks/deploy/deploy-on-docker)
+* [Deploying Dubbo services to Kubernetes](/en/overview/tasks/kubernetes/)
+
+### Governance
+
+For service governance, most applications only need to add the following
configuration, and the Dubbo application will have address discovery and load
balancing capabilities.
+
+```yaml
+dubbo:
+ registry:
+ address: zookeeper://127.0.0.1:2181
+```
+
+Once deployed and the [Dubbo Admin Console](/zh-cn/overview/tasks/deploy) is
opened, you can see the deployment and invocation data of services in the
cluster.
+
+
+
+In addition, Dubbo Admin can also enhance R&D and testing efficiency through
the following capabilities:
+* Document management, providing general services and IDL document management.
+* Service testing & Service Mock.
+* Service status inquiry.
+
+For more complex microservices practice scenarios, Dubbo also offers many more
advanced service governance features. For more details, please refer to the
documentation, including:
+* Traffic governance
+* Dynamic configuration
+* Rate limiting and degradation
+* Data consistency
+* Observability
+* Multi-protocol
+* Multi-registry centers
+* Service Mesh
\ No newline at end of file
diff --git a/content/en/overview/core-features/service-discovery.md
b/content/en/overview/core-features/service-discovery.md
index eb091929474..e023efcc83c 100644
--- a/content/en/overview/core-features/service-discovery.md
+++ b/content/en/overview/core-features/service-discovery.md
@@ -9,3 +9,60 @@ feature:
description: >
Service Discovery with customized design for large-scale cluster with
millions of instances and rich builtin registry adaptations such as Nacos and
Zookeeper and even more by supporting customized extensions.
---
+
+Dubbo provides a Client-Based service discovery mechanism, relying on
third-party registry components to coordinate the service discovery process. It
supports popular registries like Nacos, Consul, and Zookeeper.
+
+Below is a basic workflow diagram for Dubbo's service discovery mechanism:
+
+
+
+Service discovery involves three roles: providers, consumers, and the
registry. In this setup, Dubbo provider instances register their URL addresses
with the registry, which aggregates this data. Dubbo consumers read the address
list from the registry and subscribe to changes. Whenever the address list
changes, the registry notifies all subscribed consumer instances.
+
+## Service Discovery for Million-Scale Clusters
+Unlike many other microservices frameworks, **Dubbo 3's service discovery is
born out of Alibaba's large-scale e-commerce microservices cluster. Therefore,
it significantly outperforms most mainstream open-source products in terms of
performance, scalability, and ease of use.** It is the best choice for
enterprises to build scalable microservices clusters for the future.
+
+
+
+* First, Dubbo's registry aggregates instance data at the application
granularity level, allowing consumers to subscribe precisely according to their
needs, thereby avoiding the performance bottleneck caused by full subscriptions
in most open-source frameworks like Istio and Spring Cloud.
+* Second, Dubbo SDK has heavily optimized the consumer-side address list
processing, adding asynchronous notifications, caching, bitmap, and various
parsing optimizations to avoid resource fluctuations commonly seen during
address updates.
+* Finally, in terms of feature richness and ease of use, besides synchronizing
basic endpoint information like IP and port to consumers, Dubbo also
synchronizes the metadata information of the server's RPC/HTTP services and
their configurations to the consumer side, allowing for finer-grained
collaboration between consumers and providers.
+
+### Efficient Address Push Implementation
+
+From the registry's perspective, it aggregates the instance addresses of the
entire cluster based on the application name (`dubbo.application.name`). Each
service-providing instance registers its own application name, instance IP:port
address information (usually also containing a small amount of instance
metadata, such as the machine's region, environment, etc.) with the registry.
+
+> Dubbo2's registry aggregates instance addresses at the service granularity,
which is finer than application granularity and thus means more data transfer.
This has led to some performance issues in large-scale clusters.
+> For the inconsistency between the data models of Dubbo2 and Dubbo3, Dubbo3
provides a [smooth migration
solution](/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/service-discovery/migration-service-discovery/)
that makes the model change transparent to users.
+
+
+
+<br/>
+Each consumer service instance subscribes to the instance address list from
the registry. Unlike some products that load all registry data (application +
instance address) into local processes, Dubbo implements precise, on-demand
address subscription. For example, if a consumer application depends on app1
and app2, it will only subscribe to the address list updates of app1 and app2,
significantly reducing the burden of redundant data pushing and parsing.
+
+<p> </p>
+<br/>
+
+
+
+### Rich Metadata Configuration
+In addition to interacting with the registry, Dubbo 3's complete address
discovery process also has an additional metadata path, known as the Metadata
Service. Instance addresses and metadata together form the effective address
list on the consumer side.
+
+
+
+The complete workflow is shown above. First, the consumer receives the address
(IP:port) information from the registry, then establishes a connection with the
provider and reads the metadata configuration information from the Metadata
Service. These two pieces of information together form the effective,
service-oriented address list for Dubbo's consumer side. Both of these steps
occur before the actual RPC service invocation takes place.
+
+> For the definition of MetadataService and a complete analysis of the service
discovery process, please refer to [Detailed Application-Level Service
Discovery]({{< relref "../../../blog/proposals/service-discovery/" >}}).
+
+> For data synchronization in microservices' service discovery models, REST
has defined a very interesting maturity model. Interested readers can refer to
the link here
https://www.martinfowler.com/articles/richardsonMaturityModel.html. According
to the article's 4-level maturity definition, Dubbo's current model based on
interface granularity corresponds to the highest L4 level.
+
+## Configuration Methods
+Dubbo service discovery extends support for multiple registry components, such
as Nacos, Zookeeper, Consul, Redis, Kubernetes, etc. It can be switched through
configuration and also supports authentication and namespace isolation
configurations. For specific configuration methods, please refer to the SDK
documentation:
+
+* [Java](/en/docs3-v2/java-sdk/reference-manual/registry)
+* [Golang](/en/docs3-v2/golang-sdk/tutorial/develop/registry)
+* [Rust](/en/docs3-v2/rust-sdk/)
+
+Dubbo also supports scenarios of multiple registries within a single
application, such as dual registration, dual subscription, etc. This is very
useful for implementing data exchange between different clusters and cluster
migration. We will add `Best Practices` examples to future documentation to
illustrate this part.
+
+## Custom Extensions
+Registry adaptation supports custom extension implementation. For details,
please refer to [Dubbo
Extensibility](/en/overview/core-features/extensibility/).
\ No newline at end of file
diff --git a/content/en/overview/quickstart/go.md
b/content/en/overview/quickstart/go.md
new file mode 100644
index 00000000000..13f9a156363
--- /dev/null
+++ b/content/en/overview/quickstart/go.md
@@ -0,0 +1,6 @@
+---
+type: docs
+title: "Quick Start With Golang"
+linkTitle: "Quick Start"
+weight: 2
+---
\ No newline at end of file
diff --git a/content/en/overview/quickstart/rust.md
b/content/en/overview/quickstart/rust.md
new file mode 100644
index 00000000000..18028862940
--- /dev/null
+++ b/content/en/overview/quickstart/rust.md
@@ -0,0 +1,6 @@
+---
+type: docs
+title: "Quick Start With Rust"
+linkTitle: "Quick Start"
+weight: 2
+---
\ No newline at end of file
