You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@servicecomb.apache.org by ni...@apache.org on 2017/12/25 02:15:32 UTC
[incubator-servicecomb-website] branch master updated: SCB-111
document translate for website general development (#13)
This is an automated email from the ASF dual-hosted git repository.
ningjiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-servicecomb-website.git
The following commit(s) were added to refs/heads/master by this push:
new 36ba901 SCB-111 document translate for website general development (#13)
36ba901 is described below
commit 36ba901e7b4f1626e05997ed2b9b37a6e819603d
Author: lijasonvip <li...@huawei.com>
AuthorDate: Mon Dec 25 10:15:30 2017 +0800
SCB-111 document translate for website general development (#13)
---
_users/customized-tracing.md | 54 ++++++++--------
_users/distributed-tracing.md | 34 +++++------
_users/local-develop-test.md | 40 ++++++------
_users/use-servicecomb-in-spring-boot.md | 102 +++++++++++++++----------------
assets/images/local_develop_test_en.png | Bin 0 -> 20494 bytes
5 files changed, 113 insertions(+), 117 deletions(-)
diff --git a/_users/customized-tracing.md b/_users/customized-tracing.md
index abfdec2..ef08da5 100644
--- a/_users/customized-tracing.md
+++ b/_users/customized-tracing.md
@@ -3,35 +3,35 @@ title: "Customized Tracing"
lang: en
ref: customized-tracing
permalink: /users/customized-tracing/
-excerpt: "自定义调用链打点"
+excerpt: "Dotting for Customized Tracing"
last_modified_at: 2017-08-15T15:01:43-04:00
redirect_from:
- /theme-setup/
---
{% include toc %}
-## 概念阐述
+## Concept Disctiption
-分布式调用链追踪提供了服务间调用的时序信息，但服务内部的链路调用信息对开发者同样重要，如果能将两者合二为一，就能提供更完整的调用链，更容易定位错误和潜在性能问题。
+A distributed call chain tracking records the service calling sequence, but developers also need information about link invocation inside a microservice to describe a complete call chain. In this way, they can locate error and identify potential performance problems more easily.
-## 前提条件
+## Prerequisites
-* 使用自定义打点功能需要首先配置并启用Java Chassis微服务调用链。
+* To use the customized dotting function, you need to configure and set the Java Chassis microservice call chain.
-## 注意事项
+## Precautions
-* 使用`@Span`注释的自定义打点功能只支持和Java Chassis调用请求同一线程的方法调用。
-* 添加`@Span`注释的方法必须是Spring管理的Bean，否则需要按这里[提到的方法](https://stackoverflow.com/questions/41383941/load-time-weaving-for-non-spring-beans-in-a-spring-application)配置。
+* The customized dotting that uses the `@Span` annotation can only be called using the thread that calls Java Chassis.
+* To add the `@Span` annotation, you must use the Bean method of Spring. Otherwise, you need to configure dotting following the procedure in this section.
-## 自定义调用链打点
+## Customized Dotting Call Chain
-该功能集成了Zipkin，提供`@Span`注释为需要追踪的方法自定义打点。Java Chassis将自动追踪所有添加`@Span`注释的方法，把每个方法的本地调用信息与服务间调用信息连接起来。
+This function integrates Zipkin and provides the `@Span` annotation to customize dotting for the method you want to track. Java Chassis automatically tracks all the methods that track the `@Span` annotation, associating the local method call information with the call information between services.
-## 使用步骤:
+## Procedure:
-### 添加依赖
+### Add dependency
-基于 ServiceComb Java Chassis 的微服务只需要添加如下依赖到 pom.xml：
+For microservices based on ServiceComb Java Chassis, add the following content to pom.xml
```xml
<dependency>
@@ -40,9 +40,9 @@ redirect_from:
</dependency>
```
-### 启用自定义打点功能
+### Enable customized dotting
-在应用入口或Spring配置类上添加`@EnableZipkinTracing`注释：
+Addthe `@EnableZipkinTracing` annotation to the application portal or the Spring configuration class:
```java
@SpringBootApplication
@@ -54,9 +54,9 @@ public class ZipkinSpanTestApplication {
}
```
-### 定制打点
+### Customize dotting
-在需要定制打点的方法上添加`@Span`注释：
+Add the `@Span` annotation to the method that requires dotting customization:
```java
@Component
@@ -75,23 +75,23 @@ public class SlowRepoImpl implements SlowRepo {
}
```
-就这样，通过使用`@Span`注释，我们启动了基于 Zipkin 的自定义打点功能。
+In this way, Zipkin-based customized dotting is enabled using the @Span annotation.
-## 定制上报的数据
+## Customize reported data
-通过自定义打点上报的调用链包含两条数据：
+The call chain reported by customized dotting contains the following pieces of data:
-* **span name** 默认为当前注释的方法全名。
-* **call.path** 默认为当前注释的方法签名。
+* **span name** which is the full name of the annotated method by default.
+* **call.path** which is the signature of the annotated method by default.
-例如，上述例子`SlowRepoImp`里上报的数据如下：
+ For example, the data reported in SlowRepoImp is as follows:
-| key | value |
-| :--- | :--- |
-| span name | crawl |
+| key | value |
+| :-------- | :--------------------------------------- |
+| span name | crawl |
| call.path | public abstract java.lang.String io.servicecomb.tests.tracing.SlowRepo.crawl\(\) throws java.lang.InterruptedException |
-如果需要定制上报的数据内容，可以传入自定义的参数：
+To customize reported data, you can specify customized parameters:
```java
public static class CustomSpanTask {
diff --git a/_users/distributed-tracing.md b/_users/distributed-tracing.md
index 77f6813..253064f 100644
--- a/_users/distributed-tracing.md
+++ b/_users/distributed-tracing.md
@@ -1,36 +1,36 @@
---
-title: "分布式调用链追踪"
+title: "Distributed Tracing"
lang: en
ref: distributed-tracing
permalink: /users/distributed-tracing/
-excerpt: "分布式调用链追踪"
+excerpt: "Distributed Tracing"
last_modified_at: 2017-08-15T15:01:43-04:00
redirect_from:
- /theme-setup/
---
{% include toc %}
-## 概念阐述
+## Concept Description
-微服务架构解决了很多单体应用带来的问题，但同时也需要我们付出额外的代价。由于网络的不稳定性带来的请求处理延迟就是代价之一。
+The microservice architecture addresses many problems of single applications but has several drawbacks, for example, network instability may lead to latency.
-在单体应用中，所有模块都在同一个进程中运行，所以并没有模块间互通的问题。但微服务架构中，服务间通过网络沟通，因此我们不得不处理和网络有关的 问题，例如：延迟、超时、网络分区等。
+In a single application, all the modules are running in the same process without interworking. However, in the microservice architecture, services are communicated through network, and we have to address network problems, such as latency, timeout, and segmentation.
-另外，随着业务的扩展服务增多，我们很难洞察数据如何在蛛网般复杂的服务结构中流转。我们如何才能有效的监控网络延迟并且可视化服务中的数据流转呢？
+As services expand, we can hardly monitor how data is transferred in the complex service architecture. How do we efficiently monitor network latency and visualize the data flows of services?
-**分布式调用链追踪**用于有效地监控微服务的网络延时并可视化微服务中的数据流转。
+The distributed tracing system efficiently monitor network latency of the microservice and visualize data flow during the service.
## Zipkin
-> [Zipkin](http://zipkin.io/)是一个分布式调用链追踪系统。 它能帮助用户收集时序数据用以定位微服务中的延迟问题，它同时管理追踪数据的收集 和查询。Zipkin 的设计基于 Google [Dapper paper](http://research.google.com/pubs/pub36356.html)。
+> [Zipkin](http://zipkin.io/) is a distributed tracing system. It helps gather timing data needed to troubleshoot latency problems in microservice architectures. It manages both the collection and lookup of this data. Zipkin's design is based on Google [Dapper paper](http://research.google.com/pubs/pub36356.html)。
-ServiceComb 集成了 Zipkin 提供自动调用链追踪能力，如此一来用户只需要专注实现其业务需求。
+ServiceComb integrates the automatic call tracing function provided by Zipkin, so that users can focus on service demands.
-## 使用步骤:
+## Procedure
-### 添加依赖
+### Add dependency
-基于 ServiceComb Java Chassis 的微服务只需要添加如下依赖到 pom.xml：
+For microservice based on ServiceComb Java Chassis, add the following content to pom.xml
```xml
<dependency>
@@ -39,7 +39,7 @@ ServiceComb 集成了 Zipkin 提供自动调用链追踪能力，如此一来用
</dependency>
```
-如果微服务是基于 Spring Cloud + Zuul 的 API 网关，例如 workshop demo 中的 manager service ，我们还需要加入如下的额外依赖：
+If the microservice is based on the API of Spring Cloud Zuul, such as the manager service of the workshop demo, add the following dependency:
```xml
<dependency>
@@ -48,9 +48,9 @@ ServiceComb 集成了 Zipkin 提供自动调用链追踪能力，如此一来用
</dependency>
```
-### 配置追踪处理和数据收集
+### Configure tracing and data collection
-在microservice.yaml文件中设置追踪处理器和数据收集服务地址
+Set addresses for the tracing processor and data collection in the microservice.yaml file.
```yaml
cse:
@@ -66,7 +66,7 @@ servicecomb:
address: http://zipkin.servicecomb.io:9411
```
-就这样，在加了两个配置项，没改动一行代码的情况下，我们启动了基于 Zipkin 和 Java chassis 的分布式调用链追踪的功能。
+In this way, we enable the Zipkin-and-Java-based chassis distributed tracing system without changing any code.
-**注意：** 如果项目中的其他依赖也引入了 zipkin （例如 Spring Cloud），可能导致 zipkin 版本不一致而运行出错，这时需要在项目 pom 中声明 zipkin 版本。
+**NOTE:** If other dependencies introduce the Zipkin system, such as Spring Cloud, running errors may occur due to version inconsistency. In this case, you need to specify the Zipkin version in the pom project.
{: .notice--warning}
diff --git a/_users/local-develop-test.md b/_users/local-develop-test.md
index f2d972a..178cb66 100644
--- a/_users/local-develop-test.md
+++ b/_users/local-develop-test.md
@@ -1,59 +1,59 @@
---
-title: "本地开发与测试"
+title: "Local Development and Test"
lang: en
ref: huawei-cloud
permalink: /users/local-develop-test/
-excerpt: "本地开发与测试"
+excerpt: "Local Development and Test"
last_modified_at: 2017-08-15T15:01:43-04:00
redirect_from:
- /theme-setup/
---
{% include toc %}
-## 概念阐述
+## Concept Description
-本小节介绍如何在开发者本地进行消费者/提供者应用的开发调试。开发服务提供者请参考[开发服务提供者章节](/users/service-definition/)，开发服务消费者请参考[开发服务消费者章节](/users/develop-with-rest-template/)。服务提供者和消费提供者均需要连接到在远程的服务中心，为了本地微服务的开发和调试，本小节介绍了两种搭建本地服务中心的方法进行本地微服务调试：
+This section describes how developers can locally develop and commission consumer and provider applications. Both service providers and consumers need to connect to the remote service center. Two methods of building Local ServiceCenter for local microservice commissioning are as follows:
-* [启动本地服务中心](#启动本地服务中心)。
+* Starting [Local Service Center](#启动本地服务中心)。
-* [通过local file模拟启动服务中心Mock机制](#mock机制启动服务中心)。
+* Starting Local Service Center [Mock mechanism](#mock机制启动服务中心)。
-服务中心是微服务框架中的重要组件，用于服务元数据以及服务实例元数据的管理和处理注册、发现。服务中心与微服务提供/消费者的逻辑关系下图所示：
+Service center is an important component in the microservice architecture, and is used for managing, registering, and detecting metadata and instance metadata. The logic relationship between the service center and microservice provider/consumer is as follows:
-
+
-## 启动本地服务中心
+## Starting Local ServiceCenter
-* **步骤1** 启动本地服务中心，可参考[运行Service Center指南](/users/setup-environment/#运行service-center)。
+* **Step 1** Starting local service center, please refer to [Setup Environment](/users/setup-environment/#运行service-center),
-* **步骤 2** 启动本地轻量服务中心后，在服务提供/消费者的microservice.yaml文件中配置ServerCenter的地址和端口，示例代码：
+* **Step 2** After local service center is started, configure the service center address in the microservice.yaml file that stores SDK configuration information, as shown in the following example:
```yaml
cse:
service:
registry:
- address: http://127.0.0.1:30100 #服务中心地址及端口
+ address: http://127.0.0.1:30100 #Indicates the service center address and port number
```
-* **步骤 3** 开发服务提供/消费者，启动微服务进行本地测试。
+* **Step 3** Develop service providers and consumers enable the microservice for local tests.
-## Mock机制启动服务中心
+## Enable Local ServiceCenter Using the Mock Mechanism
-* **步骤 1**新建本地服务中心定义文件registry.yaml，内容如下：
+* **Step 1** Create the registry.yaml file for Local ServiceCenter
```yaml
springmvctest:
- id: "001"
version: "1.0"
- appid: myapp #调试的服务id
+ appid: myapp #Commissioning service ID
instances:
endpoints:
rest://127.0.0.1:8080
```
- 注意：mock机制需要自己准备契约，并且当前只支持在本地进行服务消费端\(consumer\)侧的调试，不支持服务提供者\(provider\)
+ NOTE: The mock mechanism needs an API definition on its own. Currently, only local commissioning for service consumers is supported.
-* **步骤 2**在服务消费者Main函数首末添加如下代码：
+* **Step 2** Add the following code to the end of the Main function for service consumers.
```java
public class xxxClient {
@@ -64,6 +64,6 @@ redirect_from:
}
```
-setProperty第二个参数填写registry.yaml的系统绝对路径，注意区分在不同系统下使用对应的路径分隔符。
+ NOTE: Set the second parameter of setProperty to the absolute path of registry.yaml file in the disk. The path separator depends on the system it is in.
-* **步骤 3**开发服务消费者，启动微服务进行本地测试。
+* **Step 3** Develop service consumers and enable the microservice for local tests.
\ No newline at end of file
diff --git a/_users/use-servicecomb-in-spring-boot.md b/_users/use-servicecomb-in-spring-boot.md
index 907ae0d..446dc09 100644
--- a/_users/use-servicecomb-in-spring-boot.md
+++ b/_users/use-servicecomb-in-spring-boot.md
@@ -1,41 +1,41 @@
---
-title: "在Spring Boot中使用ServiceComb"
+title: "Use ServiceComb in Spring Boot"
lang: en
ref: use-servicecomb-in-spring-boot
permalink: /users/use-servicecomb-in-spring-boot/
-excerpt: "在Spring Boot中使用ServiceComb"
+excerpt: "Use ServiceComb in Spring Boot"
last_modified_at: 2017-08-15T15:01:43-04:00
redirect_from:
- /theme-setup/
---
{% include toc %}
-## 使用Service Center和治理中心管理Spring Cloud应用
-### 概念阐述
+## Using the Service Center and Governance Center to Manage the Spring Cloud Application
+### Concept Description
-本小节介绍在SpringCloud原生应用中，通过改变相关配置，让SpringCloud应用使用ServiceComb微服务框架中的Service Center和治理中心。
+This section describes how to change configurations in the native Spring Cloud application to allow the Spring Cloud application to use the service center and governance center in the microservice framework.
-### 场景描述
+### Scenario
-* SpringCloud应用默认情况下由Spring Cloud Eureka提供在分布式环境下的服务发现和服务注册的功能。
+* The Spring Cloud Eureka client provides the service discovery and service registration function in the distributed environment by default.
-* ServiceComb微服务框架中的Service Center用于服务元数据以及服务实例元数据的管理和处理注册、发现，同时还支持以下功能：
+* The service center in microservice framework is used to manage and process registration and discovery of service metadata and service instance metadata, and also supports the following functions:
-> * 支持pull/push两种模式监控实例变化
+> * The pull and push modes used to monitor instance changes
>
-> * 实例动态扩容，海量的长连接或者短连接
+> * Dynamic instance scale-out, massive persistent connections, or short connections.
>
-> * 支持灰度发布、服务分组等高级管理特性
+> * Advanced management features, such as gray release and sersvice grouping.
-使用SpringBoot/Cloud开发应用，并让服务运行于ServiceComb微服务SDK容器中，使用其高性能通信、服务治理、分布式事务管理等功能。
+You can use Spring Cloud or Spring Boot to develop applications, enable services run in the microservice SDK container, and use functions, such as high-performance communication, service governance, and distributed transaction management.
-### 配置说明
+### Configuration Description
-使用SpringBoot/Cloud开发应用，在原有应用的基础上按照以下步骤进行操作，即可对接ServiceComb的SDK各组件：
+Use Spring Boot or Spring Cloud to develop applications and perform the following steps based on the original application to interconnect with the SDK components of ServiceComb.
-* **步骤 1** 在pom中添加依赖管理dependencyManagement：
+* **Step 1** Add dependencyManagement to teh POM file:
```xml
<dependencyManagement>
@@ -51,21 +51,21 @@ redirect_from:
</dependencyManagement>
```
-* **步骤 2** 在pom中添加依赖：
+* **Step 2** Add the following dependency to POM file.
```xml
<dependency>
- <!--让服务运行于微服务sdk容器中-->
+ <!--let services run in the microservice SDK container.-->
<group>io.servicecomb</group>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<dependency>
- <!--使用服务中心-->
+ <!--Use Service Center.-->
<group>io.servicecomb</group>
<artifactId>spring-boot-starter-discovery</artifactId>
</dependency>
<dependency>
- <!--让服务运行于Spring boot embedded tomcat中-->
+ <!--Let Servieces run in Spring boot embedded tomcat-->
<group>io.servicecomb</group>
<artifactId>spring-boot-starter-transport</artifactId>
</dependency>
@@ -78,9 +78,9 @@ redirect_from:
</dependency>
```
-* **步骤 3** 配置处理链和协议：
+* **Step 3** Configure the processing chain and protocol:
- 在resources目录下新建microservice.yaml文件，对服务进行定义，详细定义规则请参考[服务定义章节](/users/service-definition/)，示例如下：
+ Create the microservice.yaml file in the resources directory and define the service. For details, see Service Definition. For example:
```yaml
APPLICATION_ID: discoverytest
@@ -90,33 +90,33 @@ redirect_from:
cse:
service:
registry:
- address: http://127.0.0.1:30100 #服务注册中心地址
+ address: http://127.0.0.1:30100 #Service Center registration
rest:
- address: 0.0.0.0:8080 #服务发布的端口
+ address: 0.0.0.0:8080 #Port number released by the service
handler:
chain:
Provider:
- default: bizkeeper-provider #调用的处理链
+ default: bizkeeper-provider #Call processing chain
```
-* **步骤4** 若要使用ServiceComb的服务中心：
+* **Step 4** To use the ServiceComb configuration center, run the following commands
- 在pom中添加依赖：
+ Add the following dependency to POM file:
```java
<dependency>
- <!--使用服务中心-->
+ <!--Use the configuration center-->
<group>io.servicecomb</group>
<artifactId>spring-boot-starter-discovery</artifactId>
</dependency>
```
-* **步骤 5** 在启动类添加注解@EnableServiceComb：
+* **Step 5** Add the annotation @EnableServiceComb to the main class:
```java
@EnableDiscoveryClient
@SpringBootApplication
- @EnableServiceComb //新增注解
+ @EnableServiceComb //new annotation
public class xxxServer {
public static void main(String[] args) {
SpringApplication.run(xxxServer.class, args);
@@ -124,7 +124,7 @@ redirect_from:
}
```
-* **步骤 6** 定义服务契约，具体请参考[服务契约](/users/service-contract/)，示例如下：
+* **Step 6** Define the API definition. For details ,see [Service Contract](/users/service-contract/):
```java
// ControllerImpl.class:
@@ -139,31 +139,29 @@ redirect_from:
}
```
-* **步骤 7** 启动xxxServer，该服务便可注册到ServiceComb的Service Center。
+* **Step 7** Start the xxxServer. The service can be registered in the service center of ServiceComb.
-## 在ServiceComb框架中集成Spring Boot框架
-### 概念阐述
+## Integrating Spring Boot into Java Chassis
+### Concept Description
-本小节介绍了在ServiceComb框架中集成SpringBoot框架的好处和操作步骤。
+This section describes advantages and procedures of integrating the Spring Boot framework in the Java Chassis framework.
-### 场景描述
+### Scenario
-#### **SpringBoot框架**
+#### **Spring Boot framework**
- Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。从最根本上来讲，Spring Boot就是一些库的集合，它能够被任意项目的构建系统所使用。Boot的功能是模块化的，通过导入Boot所谓的"starter"模块，可以将许多的依赖添加到工程中。
+ Spring Boot is a new framework provided by the Pivotal team. It is designed to simplify the initial establishment and development of new Spring applications. The framework is configured in a specific manner so that developers do not need to define the sample configuration. Spring Boot is a collection of some databases and can be used by the construction system of any projects. The Boot function is modularized. By importing the starter module of Spring Boot, you can add many dependencie [...]
-#### **在ServiceComb中集成SpringBoot**
+#### **Integrating Spring Boot into ServicComb**
- 使用原生的ServiceComb框架开发微服务应用，如若需要使用ServiceComb框架提供的各项功能服务，需要在微服务项目工程pom文件中添加相应的依赖包，例如需要使用ServiceComb框架提供的负载均衡服务，需要添加handler-loadbalance包依赖。这样可以把ServiceComb提供的能力以starter的方式插入Spring Boot中，同时使用Spring Boot中提供的其他开箱即用的starter（例如SpringCloud）一起构建微服务。
+ You need to use the native Java Chassis framework to develop microservice applications. To use the functions provided by the Java Chaasis framework, add dependency packages to the POM file of microservice project. For example, to use the load balancing service provided by the Java Chassis framework, add the dependency package of the handler-loadbalance package. In this way, functions provided by ServiceComb can be inserted into Spring Boot in the manner of starter, and the microservice [...]
-### ServiceComb集成SpringBoot
+### Integrating Spring Boot into ServiceComb
- 首先使用ServiceComb框架开发微服务应用，详细步骤请参考[开发服务提供者](/users/service-definition/)与[开发服务消费者](/users/develop-with-rest-template/)。然后在这个基础上集成SpringBoot框架。
+ You need to use the Java Chassis framework to develop microservice applications, and then integrate the Spring Boot framework.
- 在对应用进行SpringBoot框架适配前，请确保应用能够正常运行，并且能够从中央的maven库下载依赖的资源。
-
-* **步骤 1** 在工程pom文件添加<dependencyManagement>节点：
+* **Step 1** Add the dependency Management node to the POM file.
```xml
<dependencyManagement>
@@ -179,9 +177,9 @@ redirect_from:
</dependencyManagement>
```
-* **步骤 2** 添加如下依赖：
+* **Step 2** Add the following dependency:
- 引入ServiceComb提供的Spring Boot依赖
+ Import Spring Boot dependency provided by ServiceComb
```xml
<dependency>
@@ -190,8 +188,6 @@ redirect_from:
</dependency>
```
- 引入Spring Boot依赖
-
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
@@ -203,20 +199,20 @@ redirect_from:
</dependency>
```
-* **步骤 3** 在resources目录下新建application.yml文件，文件内容如下：
+* **Step 3** Create the application.yaml file in the resources directory. The file content is as follows:
```yaml
server:
- port: 7999 #此处的端口为springboot服务端口
+ port: 7999 #Port number of the Spring Boot service
```
-* **步骤 4** 为微服务启动类添加注解：
+* **Step 4** Add the following annotation for the microservice main class:
```java
package xxx
import xxx
- @SpringBootApplication //新增注解
- @EnableServiceComb //新增注解
+ @SpringBootApplication //New Annotation
+ @EnableServiceComb //New Annotation
public class xxxServer/Client {
public static void main(final String[] args) {
Log4jUtils.init();
diff --git a/assets/images/local_develop_test_en.png b/assets/images/local_develop_test_en.png
new file mode 100644
index 0000000..3e8845f
Binary files /dev/null and b/assets/images/local_develop_test_en.png differ
--
To stop receiving notification emails like this one, please contact
['"commits@servicecomb.apache.org" <co...@servicecomb.apache.org>'].